Intro to Graphics 04 - Raster Images (Part2)

hello and welcome to another lecture for introduction to computer graphics uh we've got a lot of ground to cover today so this might be a relatively long lecture not that the previous ones were particularly short but we'll see how that goes uh so you'll remember that last time we were talking about raster images right so we're going to continue that discussion of raster images and and wrap it up today that's the plan uh and we started talking about raster images we talked about what the raster images like what pixels were and we talked about resolution and and all that and we started talking about uh what we're storing for each pixel so we're going to start today with a discussion of displays and and and cameras that's fairly related to uh raster images of course but let's start with with with gamma so what is gum is obviously the third letter of the greek alphabet right well that that's not what i'm talking about yeah it is true but that's not what i'm talking about gamma has a very specific meaning in computer graphics that's what i'm talking about so here's here's how it goes let's say now forget about color for a second we're just talking about light intensity let's say zero means black okay and one means white and white okay um what is 0.5 then it's the middle gray value right that makes sense you would think actually actually 0.5 is not this middle grade value but it's it's this guy it's something a lot darker than the middle grade value it's not this it's this right why is that isn't isn't it a little bit strange let me explain you why so now if we take the all possible values between zero to one from dark to the brightest color and we're gonna we're gonna have to represent all possible values with some limited number of bits right because we always have limited number of bits let's say that we're using eight bits which is typical uh when we do that we're gonna have a a limited number of possible values that we can represent right we can't represent anything in between these values we can only represent these values of course there are not 256 uh markers here but never mind it's uh you know it's just a for representation so the point is that we're going to have some discrete values that we can possibly represent in this range uh now turns out uh for people when you look at color values that are sort of sort of dark we can sort of tell the difference between them much better than the color values that are bright so over here it's very very hard for us to tell the difference between these two colors actually i'm faking here they're both white but believe me when i tell you that it's very difficult for us to tell the difference between these two values but when the color is darker it is easier for our eyes to see the difference that's just how human visual system works and it has a whole bunch of advantages in terms of biology but i'm skipping those details what's important for us to understand is that people are better at differentiating the difference between light intensities for darker lights when when it's uh brighter it's harder for us to tell the difference but imagine this if if i'm telling you to tell me the difference of intensity values of let's call them one and two it's like two is twice as bright right but it's but the difference is just one unit if i tell you to tell me the difference between 100 and 101 the difference is going to be the same amount but the relative difference is going to be you know percentage-wise much less and where we won't be able to tell the difference that well so if i just take this this whole range of possible values and evenly divide this range into some discrete values that's not going to be very efficient for human visual system because to be able to have enough colored color values for darker colors such that we can barely tell the difference between two values here i'm going to have too many values here if i use the same distance right because i won't be able to tell the difference over here or if i just pick a value that is good enough over here then it's not going to be sufficient down there and imagine this i'm going to pick a color value and intensity for each one of my pixels right and i have on a 4k display how many pixels do i have like 8 million or something right and um let's say displaying it 60 times per frame 120 times per frame so this is a lot of information to push your display constantly so i can't be generous here and say you know what i'm just going to have a million quantized values and i'm going to pick whatever i want i'm going to be i need to be conservative here right so i need to use these um fixed number of values that i can have i need to use this more intelligently and for that reason what we do here what displays do is that they allocate more values down here more discrete values down here and fewer values over here so the separation between intensity values for brighter colors is going to be larger and separation between darker intensities will be smaller so that this fits the human visual system a lot better right so that's the that's the whole idea how how do we do this well we do this using this gamma right so let's say that this is the input value that i'm sending to my display and over here this is what my display is going to show in terms of its intensity so i'm sending it some intensity value and and over here i'm showing the intensity that is coming out of the let's say leds on my display right so if i use a function like this it's like whatever intensity i provide i'm going to get this the same intensity value but this is not how displays work displays don't linearly scale the values they they use a function that looks more like this so the intensity value in the middle here is going to correspond to something um a lot darker than the middle value right so this is kind of like the function that a lot of displays used and the simplest form of that function is uh this is just very simple um exponent exponential function um that we get over here so what i want you to see here is that using this function i have discrete values here i have same number of discrete values over here but they're squished over here and they're sort of stretched up there a little bit and the function that provides that is this simple exponential function right so this input color value or input intensity value i raise it to a power gamma that's where this gamma is coming from raise it to the power gamma and that's going to be my output right so this gamma can be in theory different for different monitors depending on what type of display it is it can have a different gamma value but there's always going to be some gamma value that will provide some some sort of nonlinear stretching of the color values of the light intensities so um notice that my my values here are between zero and one and because they are between zero and one then this function sort of works and creates a curve that shaped like this right um yeah this function wouldn't work for the range that's outside of zero and one okay so this gamma value can be different as i said but typically what we use today is gamma equal to 2.2 that's the typical gamma he hughes i'll i'll get to that get to why this is the case in a little bit uh so what's important to understand is that so this is my inputs color value that i'm providing to my display but the intensity that i see from the pixels of my display are going to be this output value that's going to be scaled by this gamma right so if i want if i if there is a particular desired intensity that i want to see from my monitor then i need to um i need to send it such that i need to scale it by one over gamma to the exponent one over gamma so that when i send it to my display that's the intensity that i that i will end up seeing in my display right so this is a design value this is how i send it so what what this means is that um the images that we display the images that we record and display they are uh what we call gamma corrected so uh if if i have a desired value what i'm going to put in an image file we talked about various image file formats right what i'm going to save the disk is going to be this c in value right so i'm going to take my desired value i'm going to adjust it gamma corrected put it here and then when i send this value to my monitor i'm going to get the the desired value display on my monitors right so that's the that's the idea okay let's see uh now let's get back to this this gamma equal to 2.2 thing where is this coming from well this is this is related to um this was in the in the past all monitors there are different monitors they use different types of gamma values today 2.2 is pretty much the standard because it's related to the srgb standard that that most of our display devices use um not all of our display devices are srgb devices actually um some of your mobile phones may not be srgb they might be using slightly different color standards uh but srgb is the the the most widespread uh standard that we have for this place most computer monitors and tvs would be using srgb standard and the gamma for that is kind of like 2.2 and actually actually the exact function that the srgb standard uses srgb means standard rgb the srgb standard uses is a little more complicated than the simple exponent function so that's why this is not exactly 2.2 because it's not that function right but if you were to write this as a function of some color to gamma value uh that gamma value will be a function of the input value so that that gamma will look something like this right if you were to write it in this gamma form um so uh the exact value of that gamma would would change depending on what the input value is but for a a significant portion of this this range it's very close to the 2.2 line here that's why 2.2 works really well for most graphics applications we don't care about this additional complexity of this how this conversion is conversion function is implemented we just assume that it's a simple power gamma function and we use gamma equal to 2.2 and that's very very close actually i'm not sure if if you can see it there is a dashed line here i believe it's showing uh what the simple gamma function produces it's very very close to the actual curve so the difference doesn't really matter that much right so that's what we use and if you want to gamma correct your your desired intensity values of course you you take to take them to the power of one over this gamma value right all right any questions out there here so this is gala we it's an additional complexity that we sort of have to deal with all right going to our displays so these are our displays now we can talk about color just a little bit so this display is filled with a whole bunch of leds for each pixel uh so we know that these are rgb displays they're going to have three color values uh the way that most displays today would produce a pixel color would be using something like this for each pixel we're going to have three leds one for each color uh and you know since these are small smaller than the pixel it's kind of difficult to see them we perceive it as just one color instead of three separate colors side by side because because the pixels are very very small but if you look at your display width with some magnifying glass you should be able to see these three different leds um and this is not necessarily the only pattern they can be horizontal vertical they can they can be placed in different ways in different monitors and but this is the typical standard uh so this is for display devices that's how they display a color um if you look at cameras cameras a little bit different so i'm going to take this um to show you the the sensor over here uh behind the objective uh so uh here you see that the sensor and here will be composed of a bunch of uh pixels sensing light right doing the opposite of what leds do instead of producing light you're gonna be sensing light right now you might be surprised to see this but these um these sensors are very very small so it's very hard to um generate an area of sensors like this such that they will uh capture each uh rgb color component uh for each pixel they wouldn't do that well instead what they use is something like a bear pattern like this so for each pixel they capture only one of the color values one of the three colors so when you take a photograph with your digital camera you think that for each pixel you have a color but for each pixel you only have actually one of the color components not the others not the other two um so what happens is that um but cameras will grab this from their sensors and they're they're gonna just fill in the in between values so if you look at here we have for each two by two area uh we have two green uh sensors and one red and one blue sensor because turns out uh green is being sort of near the middle of our visual range uh is uh we're more sensitive to the intensities of green green lights so green becomes a little more important to capture than the red and blue that's why they capture green uh more accurately than red or blue uh and for uh so so only half of these pixels capture the green light right for all the others they just interpolate the neighboring values so you take the neighboring green values for four neighboring green values you integrate them and that becomes the green value of a pixel if that pixel does not have a green value of its own and you do something similar for the red and blue as well of course there's a lot more interpolation going on so if you look at a an image captured from a digital camera uh sometimes you might get to see that the green will have sort of better detail and blue and red is not going to have as much detail because they're captured in lower resolution so that's very very typical for digital cameras so when they tell you my camera is n megapixel this is what they're talking about right so if you really want to get high quality photos you kind of need to capture them in much higher resolution than you need and then you scale them down so you actually have enough data and enough high quality data all right uh but if your camera has a sensor area like this you are lucky because not well cheaper cameras won't have array uh these 2d array sensors like this they will typically have these 1d arrays and those 1d arrays will be getting data one line at a time or they will have a 2d array instead of just moving this physically they will be reading it one after the other uh so they won't be reading the whole thing at once but they're reading it one line at a time uh and this is called um shutter and um so you can you can have well shutter had different meanings for uh older cameras but for digital cameras you know it's it's it's uh gaining a totally different meaning in this case um so this is called roller shutter and the roller shadow would have like if you're moving your camera you'll see that the the images will will shift a little bit because they're not reading every pixel exactly at the same time so you get some these uh shifting skewing effects all right so thinking about these cameras and and displays and in the way that they they uh either capture pixels or display pixels uh you may get the sense that a a pixel looks something like this like uh a pixel kind of looks like and a little square with some color on it right but that's not and that's not a proper way of thinking about a pixel a more proper way of thinking about pixel is thinking about them as like a color value defined at the center of some location over here so the code the famous code is that a pixel is not a little square right a pixel just uh displays the color value at a point that point being at the center of of that pixel location uh this is a more proper way of thinking about pixels in the context of computer graphics yes the display devices will show you little squares because that's the best they can do but this is a more proper way of thinking about a pixel mathematically so if i want to display an image that looks like this my pixels will be displaying the color exactly at a point that correspond to the center of the pixel now uh of course this image that i'm showing here is very very low resolution and you won't be able to show the stop sign properly right so you have some sharp details here in this image and you won't be able to see them with such a low resolution image so what we do to make this look a little better is that we get rid of these what we call high frequencies high frequency meaning these sharp changes sharp edges uh in this image data so we think about this and i'll talk more about this much later we think about an image as like a 2d signal and these um pixels are values at certain points for that signal and if the signal has high frequency components we won't be able to represent it properly because if we don't have enough resolution so what we do is that we first blurt it out and if you blur it out you don't have these sharp edges anymore then you have enough resolution to present that data right so this is a more proper way of thinking about pixels in the context of computer graphics all right now our next topic is this important concept of alpha blending very very very important topic also turns out the subject of our first project so after i talk about this then you will know exactly how to implement the first project all right alpha blending so what is alpha obviously alpha is the first letter of the greek alphabet right no that's that's not what i'm talking about uh what i'm talking about is its meaning in the context of computer graphics it we use alpha to indicate opacity values so if alpha is zero that means something is fully transparent if it's alpha is one that means it's fully opaque so that you see it so up either see through it or you see it right and l alpha of course can be a value in between zero and one to the to um indicate different levels of uh transparency or opacity all right so the way that we're going to use alpha for raster images is that we're going to store an alpha value for each pixel a separate alpha value for each pixel so for each pixel i'm going to have a color and alpha so instead of rgb i'm gonna have rgb a a corresponds to alpha here right so i'm gonna have four values per pixel if i'm encoding alpha in a raster image so and this actually turns out to be something very very convenient and nice so if i'm using 8 bits per channel then my rgba pixel value will be 32 bits so this is the typical word side size for a 32-bit computer of course we're using 64-bit computers now but still 32-bits is a very very convenient value it's going to be cash friendly and all so so we like that and when we're storing the uh rgba images uh rgb raster images a typical storage will be using this interleaved storage where each pixel will have its own rgba rgb rgb rgb values and secondly this is the this is the format that we will be expecting from our images in the project so for project one when you're getting an image it's going to be in this interleaved storage format uh using the scan line order all right with rgb rgb igba uh they can also be of course um stored as separate channels uh and there are use cases where this this makes more sense but um you know typically they're more often uh stored as intelli uh as rgba values one after the other like this all right so we want to do alpha blending so the concept of alpha blending is that i have multiple images and i'm going to combine them together to form a single image and i'm going to use the transparency information provided in this alpha channel of of my raster images right so let's say that i have this background image and i would like to put something like this on it you may like it you may hate it it doesn't matter it's something so basically what i did is that i took an image uh here you see on on your left this this the first image is an image which has has has some transparency some alpha values that are not one less than one and there are pixels with alpha values there are one of course uh so i'm using this uh checkerboard text pattern at the back to indicate transparency right because if something is transparent you won't get to see it so i'm presenting as a checkerboard pattern that's a very typical thing to do actually um so i with alpha blending what i would like to do is i would like to take that image and put it on top of this other image and for each pixel i'm going to be doing uh what we call alpha blending and so here's how it works uh my first image has a color and alpha values it's my foreground color foreground alpha for each pixel and over here i have my background color value so this alpha blending function will show the foreground color as much as it has opacity and for the remaining part of its opacity one minus alpha is going to show the background color all right so um basically i am seeing the foreground color [Music] as much as i have opacity right so if the alpha value is one i'm going to be fully seeing the foreground color and i'm not going to see any of the background color because this is going to be zero right if alpha is zero then this term is going to disappear and this term is going to be one then i'm going to be seeing the background if it's anything in between it's basically going to be a linear interpolation uh between the the background color value and the foreground color value so this is a very typical linear interpolation formula and the the interpolation coefficient here is the alpha value of our foreground image all right very simple this is the typical standard formula for of a value but of course when you look into this and you try to implement something like this all of a sudden you realize oh wait a minute wait a minute you're talking about rgba images um what if my background has some alpha value as well what do i do then because this formula does not really do anything about it what do i do well let's talk about how to do this properly of course this formula is going to get a little more complicated but it's still the same very same concept right so i can uh i can combine the alpha values as well using alpha blending so in this case i'm combining the alpha values uh so uh this is going to get the foreground alpha plus whatever is remaining of foreground alpha i'm going to see the background alpha now you can think about this this formula this is this is actually an important thing to understand um here's how to think about this imagine that i have this pixel and a part of this pixel is covered covered partially covered by my foreground image and this alpha value tells me what percentage of that pixel is covered by my foreground image right and for that for that percentage of my pixel i am going to be seeing the foreground image for the remaining percentage of that pixel that's one minus alpha i'm going to be seeing the background image right and if the background image is not fully opaque that is its alpha value is not one then you know this is as much of the background that i'm going to get right so if the background alpha is one regardless of what foreground alpha is this formula will give me one in the end [Music] right because uh if this is one you know this uh minus alpha four gram and uh positive other four and they'll cancel out each other i'm gonna get one alpha is always going to be one if this background output one if the background alpha is not one i'm going to get something uh something larger than foreground alpha because i'm adding adding the background to the remaining part of the foreground all right okay so this is the alpha value that i'm going to get oh shouldn't i be using that alpha value for here determining the color as well our problem should because if there's an alpha value here you know i'm multiplying this guy with its alpha so maybe i should multiply this guy with its alpha as well right that's that's only fair so yeah i'm gonna have to multiply that with its alpha as well but here's something funny happen now if you look at this carefully i'm sort of i have this alpha times color here and alpha times color here so probably i'm what i'm getting here is this alpha times color so it would make sense to sort of divide it by this alpha right so again if the background alpha is one then this alpha becomes one as well so this whole equation simplifies to the the form that i showed you first if the background alpha is not one this is the more proper way of handling this all right but what if the resulting alpha value is zero it can't happen right so i can get zero here division by zero uh oh i'm in trouble so uh yeah that's that's a little bit of a problem that you kind of need to look into well if the background alpha is uh sorry the resulting alpha value is zero it can only happen if both foreground and background alpha are zero so this is the only case where i'm going to get alpha is equal to zero over there and if both of them are completely transparent guess what i'm not going to see anything through that color so it doesn't really matter what i pick as the color over here i can just say that all right the color is i don't know background color and i'm done so yeah i can arbitrarily pick something and that would be okay because that's going to disappear anyway for all the blending purposes anyway okay so there's another important concept of pre-multiplied alpha and straight alpha uh so most images that we'll see will be recorded in this form straight alpha we're going to have rgb a channels and yes it does extend to multiple stacked images you know what let me answer that question first this whole concept let me go back extends to uh multiple stacked images so the way that i'm going to handle this is that i'm going to uh take the result of this and then i'm going to use this as my background image and add my next image on top right so every time i'm looking at two images basically i combine two images and then and then i put the one on top and over that and one over that and so forth so we do it one one after the other uh of course you can write the whole formula for the entire image that contains multiple um multiple levels but it's going to be equivalent so it's easier to think about as just two images at a time all right so this is straight alpha most of our images will be recorded in this form but when we're trying to display those images what we're going to be seeing is that well if a pixel is transparent sort of semi-transparent i'm not going to see it fully so what i'm going to be seeing on my display will be these uh color values multiplied by their alpha values that's why i'm going to be ca of course you can do some something like alpha blending here um and that's typical if my background is black this is exactly the color value that i'm going to be seeing if my background is not black let's say if my background is white then i'm going to have some alpha blending right that's how i display images that have alpha values nonetheless i'm going to have to multiply i'm going gonna have to multiply each color channel by the alpha value when i'm displaying it and i'm also going to do that while i'm doing alpha blending so it kind of makes sense to instead of storing these values as they are like this kind of makes sense to store them like this right because this is what i'm going to need in the end and this is called pre-multiplied alpha some image formats support pre-multiplied alpha and some of them don't um so this makes sense because this is going to save you computation on the other hand imagine this imagine when alpha value is zero if alpha is zero for any pixel then it doesn't matter what the color value here is just going to be zero right and when i multiply it when i multiply it i'm gonna get zeros here uh so i pretty much destroyed my color information whatever it was by recording it as pre-multiplied alpha all right that so if i'm going to manipulate those images maybe i'm going to change the alpha channel later on that's not going to be that's not going to be very nice okay but 0 was a very specific case let's say that my alpha le was not 0 but but just some small value if it's some small value i'm going to be multiplying my color values with that small value and they're going to get i'm going to get some small values here right so our g and b values that i'm going to get here to store will be very small values and for small values i have limited precision because i'm quantizing my color values so i'm going to lose some information because of that quantization so if i change this alpha value later on with some image manipulation i won't be able to recover my color values that well and that's why it's more typical to store colors uh to store images using straight alpha as opposed to pre-multiplied alpha because here i'm not losing any information yes i'm gonna have to do multiplication every time i'm displaying this image but that's okay it's not too expensive today it's fairly cheap for today's computers and that's why pre-multiplied alpha is sort of not very popular anymore but i would like you guys to know that this concept exists and you may run into pictures and image formats that are recording data as pre-multiplied alpha okay uh actually when we do alpha blending with a background image we sort of get a pre-multiplied alpha color so the output of alpha blending will be this unless you divide by the alpha value right then that's why we've been dividing by the alpha value in the previous formulas all right that's all i've got for alpha blending so with this i believe you have all the information you need for implementing the first project all right i'll move on to my last topic that that's about blending a bit more generally different blending modes so alpha blending is the typical the standard way of doing blending but you can do blending in different ways as well it's not the only way of blending two images uh so one way of doing blending is additive blending so i can just basically add image intensity values like this so i have this this background that's that's black and i have this red green and blue circles in this image and the output is just the sum of all these intensities for each pixel fairly simple blending function right so in function four if i have a foreground in the background the output is just going to be the sum of the two simple enough very simple blending factors actually gpus support this this blending function it's uh it has there are some use cases for this where this is actually very very handy but if my images have alpha channels if my foreground image is in alpha channel this is going to be just a little more complicated right so the alpha value that i'm going to get in this node is going to be the sum of the two of them i mean there might be different ways to implement this but this is i would think that a typical way of implementing this uh so if if i have alpha values and i kind of need to change um i kind of need to make sure that the alpha values are contained within the valid range because if i might have alpha values they're both one one plus one would be two two is a meaningless alpha value because alpha values they have to be between 0 and 1. so i'm going to clamp it and make sure that they're between the results between 0 and 1. and if the result is between 0 and 1 i also kind of need to modify the resulting color value using alpha so i just multiply the color values by their own alpha values and divide by the resulting alpha that's going to be my output color of the color that is not a pre-multiplied alpha all right um so that's a typical way of handling it but um well i believe what gpus will implement by default will be will be just this just add the two values at the office uh here's showing what the additive blending looks like i have two images again one of them has some transparent pixels i the four the background does not have any transparent pixels so basically i'm just adding the color values of the foreground image on top of the background image so as you see the u here was uh white so that it cannot be brighter than white the pixels cannot be brighter than white so you appears perfectly crisp because it sort of uh dominates those pixels they're sort of overexposed and you get white out of there right and this is the typical function that we used so for these functions just to keep things simple i'm going to assume that background image does not have an alpha value or i'm ignoring itself alpha valley so i'm just adding the foreground image with its alpha value right uh just to you know give these ideas in a simpler format uh another one that's sort of commonly used uh is um so question what is the final alpha value you're dividing by the final alpha value i believe you're talking about this it's it's this alpha value right whatever this is that's what's going to be over here right um all right so editing blending is this difference blending is another one this is actually used uh quite a lot for for different purposes uh you can use this for oh i have this um image that has dark areas bright areas i'm gonna put some text on it uh what color text should i pick if i pick white it's going to be okay for dark areas but not good for black areas but it's it's going to be it's going to be difficult to pick a color value if your background images different different color intensities uh so so you can use this difference uh difference blending in which case the the your your resulting color would change based on the difference and this is the difference formula uh and it's using the absolute value of the difference between these two colors and so because it's using the absolute value the order doesn't really matter you get the same value and this is also used a lot for all sorts of comparisons in computer graphics i have one algorithm producing an image i have another algorithm producing a similar image and i want to see how similar they are are they producing the exactly the same image or is there some differences and i want to be able to see those differences and for those cases we use image differencing quite a lot actually it's a very good um scientific tool for all sorts of graphics algorithms um another one that i like a lot is this multiply blending mode uh you just multiply the colors uh and this is great like if i want to put some uh dark text on uh an image or some some dark item on some image uh but not completely black if i put something black this multiply is going to make the result black right if one of these is black the result is going to be black but if i have some some dark color in this case the default color is kind of dark you get sort of darkening here but you can still see the background image through it it's very very helpful and all the white stuff disappears completely so you in this case completely disappeared right uh so that's that's one way of adding something that that doesn't have an alpha channel so if i had an image that doesn't have an alpha channel i can still make it look like it has some sort of an alpha channel by making certain pixels white and those pixels disappear it's a very very helpful tool if i have an alpha channel here the formula looks a bit more complicated this is what i cooked up for this particular blending mode so basically it's the same thing right just multiply the two colors but i'm using it as much as i have alpha in the foreground and for the rest of the opacity one minus alpha i'm using the background color directly so that's a typical way of handling it that might be uh slightly different ways of handling it as well but this is this is what i would use uh so this multiplier blending screen blending is the opposite of multiply blending now for multiply blending i i'm getting i'm seeing darker colors i'm sort of um sort of eliminating brighter colors if you look at it sort of you hear disappears um screen blending would do the exact opposite now dark pixels wouldn't do anything but bright pixels would uh would overwhelm and and show up and the way this works is actually this is the disguised multiply blending disguise in a way that the way that i'm computing this is um is first i'm going to take the inverse of the first image you just take one minus the color value whatever that is and inverse of the second image and then i'm going to multiply the two as you can see here i'm multiplying the two and i get this image right and if i take the inverse of that one minus whatever that is i get the the final screen value so that this is how this screen blending works as a very very useful tool i actually use it a lot in practice and if you compare this to edited blending it actually looks uh quite different so um editor blending screen blending right so it's uh screen blending is a lot gentler and you use a lot actually in practice all right these are not the only blending blending modes that you can think of there are a whole bunch of blending modes i'm right now i'm here i'm showing you some of the some of uh photoshop's blending modes um here we talked about alpha blending that's a normal mode that's what it does when you have normal blending and then we talked about multiplying talked about screen but there are all sorts of other ones actually they're more than those there are other ones there and it's here differences here but there are a whole bunch of light modes and there's even more and these are all the blending modes in photoshop there could be there could be more that you can come up with basically any function that combines pixels of two image would be a blending mode but these are the ones that are provided by photoshop presumably they're useful to people in different ways all right but what i would like you to think about is this this is this is very very important this is a standard way of alpha planning is the standard way of blending two images uh and that's why it's called normal mode in uh in photoshop it doesn't even say alpha blending um because yeah alpha is actually involved in all of these blending modes in one way or another all right all right so that's uh that was all the material we have for this lecture well thank you all for tuning in and um i'll post this video online with the others and um good luck with the project hopefully that's going to be very easy thank you thank you thank you

Channel: Cem Yuksel

Views: 2,593

Keywords:

Id: PMIPC78Ybts

Length: 47min 28sec (2848 seconds)

Published: Sat Jan 30 2021