Everyone and welcome to this Python and open
CV course. In this course, we'll be talking about everything you need to know. To get
started with open CV in Python, we're going to start off with the very basics that is
reading images and video, manipulating those media files with image transformations, and
how to draw shapes and put text on those files. Then we're going to move on to the most advanced
parts of open CV that is switching between color spaces bitwise operators, masking, histograms,
edge detection and thresholding. And finally, to sum things up, we'll be talking about face
detection and face recognition in open CV, so how to detect and find faces in an image
and how to recognize them using inbuilt methods. In the last video, we'll be building a deep
computer vision model to classify between the characters in The Simpsons based off some
images. All material discussed will be available on my GitHub page, and all relevant links
will be put up in the description below. If that sounds exciting, don't forget to head
over and subscribe to my channel. And I'll see you in the course. Hey, everybody, and
welcome to this Python and urban TV coast. Over the next couple of videos, we're going
to be talking about using the open CV library to perform all sorts of image and video related
processing and manipulations. Now I won't be delving into what open CV is really is.
But just be brief. It is a computer vision library that is available in Python, c++ and
Java. A computer vision is an application of deep learning that primarily focuses on
deriving insights from media files, that is images and video. Now, I'm going to assume
that you already have Python installed on your system. And a good way to check this
is by going to terminal and typing Python dash dash version. Now make sure you're running
a version of Python of at least 3.7 above whatever we do in this post wonderly work
in some older versions of Python, and especially Python two, so just make sure that you have
the latest version installed, go ahead to python.org and download the latest version
from bet. Now assuming that you've done this, we can proceed to installing the packages
that we require in this course. The first one is open C. So go ahead and do a pip install
Open CV dash contrib dash Python. Now sometimes you may find people telling you to install
just open CV dash Python. Well, this open team dash Python is basically the main package
the main module of open CV, open CV dash contract dash Python includes everything in the main
module, as well as a contribution modules provided by the community. So this is something
I recommend you install as it includes all of open CV functionality. You may also notice
that urgency, we tried to install the NumPy package. Now NumPy is kind of a scientific
computing package in Python, that's extensively used in matrix an array manipulations, transformations,
reshaping and things like that. Now, we'll be using NumPy in some of the videos in this
course. But don't worry if you've never used them before. It's simple and relatively easy
to get started with. Now the next package, I'd like you to install a sphere. So go ahead
and do pip install seer. Now, slight disclaimer, this is a package that I built to basically
help you to speed up your workflow. Sierra is basically a set of utility functions that
will prove super useful to you in your computer vision journey. It has a ton of super useful
helper functions that will help speed up your workflow. Now, although we're not going to
be using this for a good part of this course, in fact, we'll only begin to use this in our
last video of this course when we're building a deep computer vision model. I recommend
you install it now so that you don't have to worry about the installation process later
on. If you're interested in contributing to this package, or just simply want to explore
the codebase I'll leave a link to this GitHub page in the description below. Okay, that's
it for this video. In the next video, we'll be talking about how to read images and video
in open CV. So I'll see you guys in the next video. Hey everybody, and welcome back to
another video. In this video, we're going to be talking about how to read images and
video in open CV. So I have a bunch of images in this photos folder, and a couple of videos
in this videos folder. In the first half of this video, we'll be talking about how to
read in images in open CV, and towards the end we'll be actually talking about how to
read in videos. So let's start off by creating a new file and call this reader dot p y. And
the first thing we have to do is actually input CV two as CV. So the way we read in
images in open CV is by making use of the cv.im read method. Now this method basically
takes in a path to An image and returns that image as a matrix of pixels. Specifically,
we're going to be trying to read this image of a cat here. So we're going to say photos
slash cat dot jpg. And we're going to capture this image in a variable called IMG. Now you
can also provide absolute paths. But since this photos folder is inside my current working
directory, I'm going to reference those images relatively. Now once we've read in our image,
we can actually display this image by using the cv.rm show method. Now this method basically
displays the image as a new window. So the two parameters we need to pass into this method
is actually the name of the window, in this case is going to be kept and the actual matrix
of pixels to display, which in this case is IMG. And before we actually move ahead, I
do want to add an additional line a CV dot wait key zero. Now the CV or wiki zero is
basically a keyboard binding function, it waits for a specific delay, or time in milliseconds
for a key to be pressed. So if you pass in zero, it basically waits for an infinite amount
of time for a keyboard key to be pressed. I didn't worry too much about this, it's not
really that important for this course. But we will be discussing some parts of it towards
the end of this video. So let's actually save this and run by saying Python, read dot p
y, and the image is displayed in a new window. Cool. Now this was a small image, this was
an image of size 640 by 427. Now we're going to try and read in this image of the same
cat, but a much larger version, a 2400 by 1600 image. So we're gonna say Cat on a school
large dot jpg. Let's save that and run. And as you can see, this image goes way off screen.
The reason for this is because the dimensions of this image were far greater than the dimensions
of the monitor that I'm currently working on. Now currently, open CV does not have an
inbuilt way of dealing with images that are far greater than your computer screen. There
are ways to mitigate this issue. And we'll be discussing them in the next video when
we talk about resizing and rescaling frames and images. But for now, just know that if
you have images, if you have large images, it's possibly going to go off screen. So that's
it for reading images, we can then move on to reading videos in open CV. So that's called
reading videos. So what we're going to do is we're actually going to read in this video
of a dog, and the way we read in videos is by actually creating a capture variable and
setting this equal to CV dot video capture. Now this method either takes an integer arguments
like 0123, etc, or a path to a video file. Now you would provide an integer argument
like 012, and three, if you are using your webcam or a camera that is connected to your
computer. In most cases, your webcam would be referenced by using the integer zero. But
if you have multiple cameras connected to your computer, you could reference them by
using the appropriate argument. For example, zero would reference your webcam, one would
reference the first camera that is connected to your computer to would reference the second
camera and so on. But in this video, we'll be actually looking at how to read an already
existing videos from a file path. Now specifically, we'll be reading this dog, this video for
dog here. And the way we do that is by providing the path so videos, slash dog dot mp4. Now,
here's where reading videos is kind of like different from reading images. In the case
of reading and videos, we actually use a one loop and read the video frame by frame. So
we're going to say while true. And the first thing we want to do inside this loop is say
is true. And frame is equal to capture dot read. Now this capture dot read basically
reads in this video frame by frame, it returns the frame and a Boolean that says whether
the frame was successfully read in or not. Do you display this video we can actually
display an individual frame. So we do this by saying TV on show and we call this video
and we pass in the frame and finally for some way to stop the Do from playing indefinitely
is by saying if CV don't wait, Ki 20 and 0x ff is equal to equal to Ord of D. There we
want to break out of this while loop. And once that's done, we can actually release
the capture pointer. And we can destroy all windows. And we can get rid of this. So basically
just to recap, the capture variable is an instance of this video capture clause. Inside
of while loop, we grab the video frame by frame. By utilizing the captured read method,
we display each frame of the video by using the CV dot m show method. And finally, for
some way to break out of this while loop, we say if See, we don't wait ki 20 if and
0x f f is equal to or D, which basically says that if the letter D is pressed, then break
out of this loop and stop displaying the video. And finally, we release the capture device
and we destroy all the windows since we don't need them anymore. So let's save that and
run. And we get a video displayed in a window like this. But once it's done, you will notice
that the video suddenly stops and you get this error. More specifically a negative 215
assertion failed error. Now if you ever get an error like this negative 215 assertion
failed. This would mean in almost all cases is that open CV could not find a media file
at that particular location that you specified. Now, the reason why it happened in the video
is because the video ran out of frames, open CV could not find any more frames after the
last frame in this video. So it unexpectedly broke out of the while loop by itself by raising
a CV to error. And now you're gonna get the same error. If we comment this out, we uncomment
this out. And we specify a wrong path to this image. So I see me Oh wait, wait key, zero,
save that and run and we get the exact same error. This basically again says that open
CV could not find the image or the video frame at a particular location basically, it could
not be ready. That's what it's saying. So that's pretty much it. For this video, we
talked about how to read any images in open CV and how to read in videos using the video
capture class. In the next video, we'll be talking about how to rescale and resize images
and video frames in open CV. So see you then. Hey, everyone, and welcome back. In this video,
we're going to be talking about how to resize and rescale images and video frames in open
CV. Now, we usually resize and rescale video files and images to prevent computational
strain. Large media files tend to store a lot of information in it and displaying it
takes up a lot of processing needs that your computer needs to assign. So by resizing and
rescaling, we're actually trying to get rid of some of that information. rescaling video
implies modifying its height and width to a particular height and width. Generally,
it's always best practice to downscale or change the width and height of your video
files to a smaller value than the original dimensions. The reason for this is because
while most cameras your webcam included, do not support going higher than its maximum
capability. So for example, if a camera shoots in 720 P, chances are it's not going to be
able to shoot in 1080 P or higher. So to rescale a video frame or an image, we can create a
function called def rescale frame. And we can pass in the frame to be resized and scale
the value which by default we're going to set as point seven five. So what I'm going
to do next is I'm going to say with is equal to frame dot shape of one of one times scale.
And I'm going to copy this and do the same thing for the height. Now remember frame no
shape of one is basically the width of your frame or your image and frame note shape of
zero is basically the height of the image. Now since width and height are integers, I
can actually convert these floating point values to an integer by converting it to an
iron T. And what we're going to be doing is we're going to create a variable called dimensions,
and set this equal to a table of width, comma height. And we can actually return CV don't
resize the frame, the dimensions, and we can pass in it interpolations of CV dot into on
the school area. Now we'll be talking about CV dot resize in an upcoming video. But for
now, just note that it resizes the frame to a particular dimension. So that's all a function
does, it takes in the frame, and it scales that frame by a particular scalar value, which
by default is point seven, five. So let's actually try to see this in action. Let's
go back to this readout p y, and grab this code. And we can paste there, we don't need
us for now. uncomment these out. Now what I'm going to do is after I've read in the
frame, I'm going to create a new frame call frame on this go resized, and set this equal
to rescale frame of frame. And let's leave the scale value is point seven, five. And
we can actually display this video resized by passing a frame on the scope resized. Resize.
So let's save that and run Python rescale del p why that was an error. Okay, we don't
need this. Let's close that out, Save and Run. And this was our original video. And
this is actually a resize the video with the video resize by point seven 570 5%. We can
modify this by changing the scale of value to to maybe point two, so we rescaling to
20%. And we get an even smaller video in a new window. So let's close that out. Now you
can also apply this on images. So let's uncomment that out, change that to cat dot jpg. And
we can do receive our show. Image and pawson the resized image. And we can create a resize
image by calling rescale frame and we could pass in the IMG. So let's see that in Rome.
And this is a small videos we're not concerned with that. This is actually the big image
the large image. And this is the recent version of this image. So let's close that out. Now
there is another way of rescaling or resizing video frames specifically. And that's actually
using the capture dot set method. Now this is specifically for videos, and will work
for images. So let's go ahead and try to do that. Let's call this depth change rez. So
we're changing we're changing the resolution of the image of video. And we can pass in
a width and a height. And what we're going to do is we're going to say capture, don't
set three comma with and we're going to do the same thing with capture dot set four comma
height. Now three info basically stands for the properties of this capture class. So three
references the width and full references the height. You can also expand this to maybe
change the brightness in the image. And I think you can reference that by setting this
to 10. But for now we're going to be interested in the width and the height. Now, I do want
to point out this, this method will work for images, videos, and live video. Basically,
for everything you can use this rescale frame method. But the changes function only works
for live video. That is video you read in from an external camera or your webcam for
instance. So video that is going on currently, this is not going to work on standalone video
files, video files that already exist. It just doesn't work. So if you're trying to
change the resolution of live video, then go with this function if you're trying to
change the resolution of an old already existing video, then go with this function. So that's
pretty much it for this video that we talked about how to resize and rescale video frames
and images in open CV. In the next video, we'll be talking about how to draw shapes,
and write text on an image. So that's everything. I'll see you guys in the next video. Hey,
everyone, and welcome back to another video. In this video, we're going to be talking about
how to draw and write on images. So go ahead and create a new file and call this draw dot
p y. We're going to input CV two and CV, we're going to input the NumPy package that open
CV had installed previously. And we're going to input that as MP, we will read in an image
by saying OMG is equal to cv.rm, read person photos, photos slash cat dot jpg, we can display
that image in a new window. And we can do receive out of weight key zero. Now there
are two ways we can draw on images by actually drawing on standalone images like this image
of a cat to or we can create a dummy image or a blank image to work with. And the way
in which we can create a blank image is by saying blank is equal to NP dot zeros of shape
500 by 500. And give it a data type of ui 98. You ID eight is basically an image the
datatype of an image. So if you want to try and see this image, see what this image looks
like. We can say blank, and we can pass in like save that and run Python drawed or p
y. And this is basically the blank image that you can draw on. So we're going to be using
that in instead of drawing this cat image. But feel free to use this cat image if you'd
like. So the first thing we're going to do is try to paint is trying to paint the image
a certain color. And the way we do this is by saying blank and reference all the pixels
and set this equal to zero comma 255 comma zero. So by painting the entire image green,
and we can display this image by saying green in passing the blank image, save that and
run. Can I broadcast Yeah, okay, you need to give it a shape of three, basically, we
are giving the shape of height, width, and the number of color channels. So just keep
that in mind save up. And this is the green image that we get cool, we can even change
this and try to change this to red zero comma 255. Save that. And we get a red image over
here. Now you can also call a certain portion of the image by basically giving it a range
of pixels. So we can say 200 to 300. And then from 300 to 400. Save that and run and you
got a Red Square in this image. The next thing we're going to do is we're going to draw a
rectangle. And the way we do this is by using the CV don't rectangle method. This method
takes in an image to draw the rectangle over, which in this case is blank. And it takes
in point 1.2, color, thickness and a line type if you'd like. So the point one will
specifically be zero comma zero, which is the origin. And we can go all the way across
to 250 comma 250. Let's give it a color of zero comma 255 comma zero, which is green,
give it a thickness of let's say two, which is basically saying the thickness of the borders.
And once that's done, we can display this image by saying let's call this rectangle
in passing and passing the blank image. We can comment this out since we don't need this
anymore. And we get a green rectangle that goes all the way from the origin to 250 comma
250. You can play around with it if you like so we can go from 250 to maybe 500. And it
goes all the way across the image. So you basically divide the image in half. Now there
is a way of filling in this image a certain color. And the way we do this is instead of
saying thickness is equal to two, we say thickness is equal to CV dot field. That basically fills
in the rectangle to get this green rectangle. Now Alternatively, you can also specify this
as negative one, negative one. And we get the same result, what we can also do is, instead
of giving it fixed values like 250, and 500, what we could do is we could say, IMG done
shape of zero, of one divided by divided by two, and image dome shape of zero, divided
by divided by two. Let's save that and run. image is not in fact, God, this is blank,
this is blank, save that and run. And we get a nice little rectangle, or square, if you
will, in this image, what it basically did is it scaled the rectangle from instead of
being these, this entire square, this rectangle basically has dimensions, half of that of
the original image. So moving on, let's try and draw a circle. Draw circle. This is also
fairly straightforward, we do a CV dot circle. And we pass in the blank image. And we give
it a center, which basically the coordinates of the center for now let's set this to the
midpoint of this image by saying 250 comma 250. Alternatively, you could also get this
let's give it a radius of 40 pixels, give it a color of zero comma, zero comma 255,
which is red BGR. And give it a thickness of let's say three. We can display this image,
say, circle is equal to blank. And we get a nice little circle over here, that has its
center at 250 km 250, and radius of 40 pixels. Again, you can also fill in this image by
giving a thickness of negative one. Here, we get a nice little dot here in the middle.
Cool. Now there's something else that I forgot. And that is how to draw a line a standalone
line on the image. That again, is fairly straightforward, say draw a line, we use a cv.in line method.
And this takes in the image to draw the line on and two points, that's just copy these
points, basically everything. And this basically draws a point from zero comma zero to half
these image dimensions. So that's 252 50. And then it draws a line of color zero comma
255, comma zero. Let's set this to full white 2255, d 5255. And it's green thickness you
can specify as three. And we didn't display this image. See you don't on show colas line,
rule the line, blank image, and we get a line that goes all across from zero comma, zero
comma zero to 250, comma 250. Let's try and play around with this. And let's draw a line
from 100 to maybe 250. And then it goes all the way to 300 to 400, save that. And you've
got a line that goes from 100 100 to 300, comma 400. Cool. And finally, the last thing
that we will discuss in this video is how to write text on an image that that's right
text on an image. Now, the way we do this is very straightforward. We see we do a CV
dot put text. And this will put text on the blank image. We specify what we want to put
on. So let's say hello. We can give it an origin, which is basically where do we want
to draw the image from? Let's set this to 225 and 225. And we can also specify font
face. Now open CV comes with inbuilt fonts. And we will be using the CV dot font unschool
Hershey ns go. We'll be using the triple x, you have complex you have duplex you have
plain. You have script simplex and a lot of inbuilt phones. But for now, let's use a triplex.
Let's give this a font scale, which is basically how much do you want to scale the font by,
let's set this to 1.0. We don't want to scale a font, let's give it a color of zero comma
255, comma zero, and give it a thickness of two. Commit that out. And we can display this
image. So you don't I'm show let's call this text and pass in the blank image. And we get
some text that is placed on the image. You play around with it and say, Hello, my name
is Jason. Save and Run. And it goes off screen. I when we're dealing with large images, but
we can there's no way of actually handling this except for maybe changing the margins
here a bit, too, we can do that by saying let's say it's zero comma two to five. And
it sounds from zero and says Hello, my name is yes. So that's it. For this video, we talked
about how to draw shapes, how to draw a lines, rectangles, circles and how to write text
on an image. Now in the next video, we'll be talking about basic functions in open CV,
that you're most likely going to come across whatever project in computer vision you end
up doing. So if that's it, I'll see you guys in the next video. Hey, everyone, and welcome
back to another video. In this video, we're going to be talking about the most basic functions
in open CV that you're going to come across in whatever computer vision project you end
up building. So let's start off with the first function. And that is converting an image
to grayscale. So we've written an image, and we've displayed that image in a new window.
And currently, this is a BGR image, a three channel blue, green and red image. Now there
are ways in open CV to essentially convert those BGR images to grayscale so that you
only see the intensity distribution of pixels rather than the color itself. So the way we
do that is by saying gray is equal to CV dot CBT color, we pass in the image that we want
to convert from, which is IMG, and we specify a color code. Now this kind of code is CV
dealt kind of unskilled BGR. To great, since we're converting a BGR image to a grayscale
image. And we can go ahead and display this image by saying CV don't show passing gray
and pass in the gray image. Save that and run your Python basic.pi. And this was the
original image. And this is the grayscale image. Let's try this with another image.
Slide with no this is the image of a park in Boston save and maybe change that to Boston.
And this is the BGR image in open CV, and this is its corresponding grayscale image.
So nothing too fancy. We've just converted from a BGR image to a grayscale image. The
next function we're going to discuss is how to blur an image. Now blurring an image essentially
removes some of the noise that exists in an image. For example, in an image, there may
be some extra elements that were there because of bad lighting when the image was taken,
or maybe some issues with the camera sensor and so on. And some of the ways we can actually
reduce this noise is by applying a slight blur. There are way too many blurring techniques
which we will get into in the advanced part of this goes. But for now we're just going
to use the Gaussian Blur. So what we're going to do is we're going to create a blurred image.
I think blur is equal to CV dot Gaussian Blur. And this image will take an associate image
which is the IMG it will take in a kernel size, which is actually a two by two tuple
which is basically the window size that open CV uses to compute the blown the image. We'll
get into this in the advanced part of the scope so don't worry too much about this,
just know that this kernel size has to be an odd number. So So let's start a real simple
and keep the kernel size to three by three. And another thing that we have to specify
is CV dot border on school default. So go ahead and try to display this image, the same
blur, and pawson blue. Now, you will be able to notice some of the differences in this
image. And that is because of the blur that is applied on it. Right this people in the
background are pretty clear on this image. And over here, they're slightly blurred. To
increase a blind his image, we can essentially increase the kernel size from three by three
to seven by seven, save that and run. And this is the image that is way more blurred
than the previous image. So that's it. The next function we're going to discuss is how
to create an edge cascade, which is basically trying to find the edges that are present
in the image. Now again, there are many edge cascades that are available. But for this
video, we're going to be using the canny edge detector, which is pretty famous in the computer
vision world. Essentially, it's a multi step process that involves a lot of blurring and
then involves a lot of grading computations and stuff like that. So we're gonna say, Kenny,
Kenny is equal to CV dot Kenny, we pass in the image, we pass in to threshold values,
which for now I'm going to say 125 and 175. Let's go ahead and try to display this image,
get the Kenny images. And we can pass in county. Save that and run. And these were the edges
that were found in this image. As you can see that it hardly any edges found in the
sky. But a lot of features in the trees and the buildings. And quite a few, you know features
and edges in the grass and stuff. We can reduce some of these edges by essentially blurring
the image. And the way we do that is instead of passing the IMG, we pass in the blur. See
that run. And as you can see that there were far less edges that were found in the image.
And this is a way you can basically reduce the amount of edges that were found by a lot
by applying a lot of blur, or get rid of some of the edges by applying a slight blur. Now
the next function we're going to discuss is how to dilate an image using a specific structuring
element. Now the structuring element that we are going to use is actually these edges,
the canny edges that were found, so we're gonna say dominating the image. And the way
we do that is by saying dilated is equal to CV dot dilate. And this will take in the structuring
element, which is basically the canny edges. And we'll take a kernel size, which we'll
specify as three by three for now. And it will also take n iterations of one. Now, dilation
can be applied using several iterations of the time, but for now, we're just going to
stick with one. So go ahead and try to display this image by saying CV dot m shope. Call
this dilated. And we can pass in David. Save that and run. And if these were, if these
were edges, these are the dilated edges, we can maybe increase the kernel size to maybe
seven by seven and tried to see what that does hold on. And nothing much was done. Not
much difference was that let's try to increase the number of iterations to maybe three. And
it's definitely way thicker. But you're gonna see subtle differences with the amount of
features and edges that you find. Now there is a way of eroding this dilated image to
get back this structuring element. Now, it's not going to be perfect, but it will work
in some cases. So we're gonna say, call this roading and we call this eroded is equal to
CV don't erode, it will take in the dilated image, pass and dilated, it will take a kernel
size of let's start off with three by three and given n iterations of one just for now.
And we didn't display this image show coolest clothes eroded, eroded and if this was your
structuring element, and this was your dilate image, this is basically the result you get
from eroding this image. Now, it isn't the same as a structural element. But you can
just about to make the features that. But you can see that between this and this, there
is a subtle change in the edges and the thickness of these edges, we can maybe try to match
these values, so that we attempt so that there is an attempt to get back this edge cascade.
And yes, we got the edges back there, as you can see that you compare these two, they look
pretty much the same. And the edges are the same. So essentially, if you follow the same
steps, you can, in most cases, get back the same edge cascade. And probably the last function
that we're going to discuss is how to resize and crop an image. So we're going to start
with resize. So we come to resizing video frames and images in the previous video in
one of the previous videos. But we're just going to touch on the CBO resize function
just a bit. So we're going to say resized, resized equal to CV dot resize, this will
take an image to be resized, and it will take in a destination size, which let's set this
to 500 by 500. And so this essentially takes in this image of the park, and resize that
image to 500 by 500, ignoring the aspect ratio. So we display this image by saying saved out
I'm sure resized and resized. Save that and run. And let's go back to this image. If this
is the original image, this is the image that was resized to 500 by 500. Now by default,
there is an interpolation that occurs in the background, and that is CV dot into on the
scope area. Now this interpolation method is useful if you are shrinking the image to
dimensions that are smaller than that of the original dimensions. But in some cases, if
you are trying to enlarge the image and scale the image to a much larger dimensions, you
will probably use the inter underscore linear or the inter on scope cubic. Now cubic is
the slowest among them all. But the resulting image that you get is of a much higher quality
than the inter on scope area or the inter underscore linear. So let's touch on cropping.
And that's basically by utilizing the fact that images are arrays. And we can employ
something called Array Slicing, we can select a portion of the image on the basis of your
pixel values. So we can say cropped is equal to the image. And we can select a region from
50 to 200. And from 200 to 400. And we can display this image Cole is cropped, possibly
cropped. And this is a cropped image of let's go back here of this original image, you try
to superimpose them, it's probably going to be you. Yeah, it's basically this portion.
So that's pretty much it. For this video, we talked about the most basic functions in
open CV, we talked about converting an image to grayscale by applying some blur by creating
an edge cascade by dilating the image by eroding that dilated image by resizing an image and
trying to crop an image using Array Slicing. In the next video, we're going to be talking
about image transformations in open CV, that's translation, rotation, resizing, flipping
and cropping, so if you have any questions, leave them in the comments below. Otherwise,
I'll see you guys in the next video. Hey, everyone, and welcome back to this Python
and open CV course. In this section, we're going to cover basic image transformations.
Now these are common techniques that you would likely apply to images, including translation,
rotation, resizing, clipping and cropping. So let's start off with translation. Translation
is basically shifting an image along the x and y axis. So using translation, you can
shift an image up, down, left, right, or with any combination of the above. So so to translate
an image, we can create a translating function, we're gonna call this def translate This translation
function will take in an image to translate and take an x and y, x and y basically stands
for the number of pixels, you want to shift along the x axis and the y axis respectively.
So do translate an image, we need to create a translation matrix. So we're going to call
this transmit is equal to NP dot float 32. And this will take in a list with two lists
inside of it. And the first list we're going to say, one comma zero comma x, and zero comma
one comma y. And since we're using NumPy, we can import NumPy, import NumPy as NP. And
once we've created our translation matrix, we can essentially get the dimensions of the
image saying dimensions, which is a tuple of image don't shave off one, which is the
width an image dot shape of zero, which is the height. And we can return CV dot warp
a fine. This will take in the image matrix to trans MIT animal taking the dimensions.
And with that data, we can essentially translate our image. And before we do that, I do want
to mention that if you have negative values for x, you're essentially translating the
image to the left, negative negative y values implies shifting up positive x values implies
shifting to the right. And as you guessed, positive y values shifted down. So let's create
our first translated image. We're setting this equal to translate, we're going to pass
in the image, the image and we're going to shift the image right by 100 pixels, and down
by 100 pixels. That's to receive it on on the show, translated and translate tip. Save
that and run Python krones formations dot p y. And this is your translated image, it
was shifted down by 100 pixels and shifted to the right by 100 pixels. So let's change
that. Let's shift the image left by 100 pixels and down by 100 pixels. So we pass in negative
values for x and it moved to the left. Feel free to play around with these values as you
see fit. Just know that negative x shifts to the left, negative y shoves it up, x shifted
to the right and positive y values shifted down. Moving on, let's talk about rotation.
rotation is exactly what it sounds like rotating an image by some angle. Open CV allows you
to specify any point any rotation point that you'd like to rotate the image around. Usually
if the center but but with open CV, you could specify any arbitrary point it could be any
corner, it could be 10 pixels to the right 40 pixels down, and you can shift the image
around that point. So to draw to rotate the image, we can create a rotating function,
let's call this dev rotate. This will take an image angle to rotate around and a rotation
point which we're going to say which we're going to set is not so we're going to grab
the height and width of the image by pressing by setting this equal to IMG dot shape of
the first two values. Basically, if the rotation point is none, we are going to assume that
we want to rotate around the center. So we're going to say rot point is equal to width divided
by two divided by two in height divided by divided by two. And we can essentially create
the rotation matrix like we did with the translation matrix. By setting this equal to rot met is
equal to CV dot get rotation matrix 2d. We're going to pass in the center the rotation point
and angle to rotate around which is angle and a scale value. Now we're not interested
in scaling the image when we've rotated so we can set this to 1.0. value we can set a
dimensions variable equal to the width and the height and we can return the rotated image
which is a CV don't warp a fine image rot met the destination size which is dimensions.
And that's it. That's all we need for this function. So we can create a rotated image
by setting this equal to rotate, and we can rotate the original image by 45 degrees. So
let's display this image, call this rotated, and pass and rotated. Save that in rock. And
this is your rotated image. As you can see, it was rotated counterclockwise by 45 degrees.
If somehow you wanted to rotate this image clockwise, just specify negative values for
this angle, and it will rotate the image around rotated clockwise. Now you can also rotate
a rotated image that is take this image and rotated by 45 degrees further. So let's call
this rotated, rotated rotated is equal to rotate or rotate tid. And we can rotate this
image by another 45 degrees. So we're rotating it clockwise. And we can see the.on show called
is rotated, rotated. And we can pause and rotated, rotated, whatever, rotate it. And
this is your rotate rotated image. Now the reason why these black lines were included
is because if there's no image in it, if there's no part of the image in it, it's going to
be black by default. So when you took this image and rotated it by 45 degrees, you essentially
rotated the image, but introduce these black triangles. Now if you tried to rotate this
image further by some angle, you are also trying to rotate these black triangles along
with it. So that's why you get these kind of a skewed image. So there's additional triangles
are included over here. But save yourself the trouble and basically add up these angles
and you will get the final angle. So we can change that to 90 and retake the original
image by negative 90. And this is essentially the image that we were trying to go for, take
this image rotated 45 degrees clockwise and rotate this 45 degrees image by further 45
degrees, save yourself the trouble and add those two angle values. So so far, we've covered
two image transformations, translation and rotation. Now we're going to explore how to
resize an image. Now this is nothing too different from what we've discussed previously. But
let's touch on adjust a bit resizing. And we can create a resized variable and set this
equal to CV don't resize, we can pass in the image to resize and the destination signs
of maybe 500 by 500. And by default the interpolation is CV dot inter underscore area. You can maybe
change this to into underscore linear or inter underscore cubic. Definitely a matter of preference
depending on whether you're enlarging or shrinking the image. If you're shrinking the image,
you will probably go for into underscore area or stick with default. If you're enlarging
the image, you could probably use the inter underscore linear or the dansko cubic cubic
is slower, but the resulting image is better with over high quality. Again, I think it's
you different from what we discussed before. So we can display this image. I can resize
and passing and resized. Save that run and we've got a resized image. Next up we have
flipping how to flip an image. So we don't need to define a function for this, we just
need to create a variable and set this equal to CV dot flip. This will take in an image
and a flipped code. Now this flip code could either be 01 or negative one. Zero basically
implies flipping the image of vertically that is over the x axis one specifies that you
want to flip the image horizontally or over the y axis and negative one basically implies
flipping the image both vertically as well as horizontally. So let's start off with zero
claiming it vertically. I'm show call this flip in Parson boop, Save and Run. And this
is the image that was clipped vertically. Let's try out a horizontal clip how we get
a horizontal Flip, surely see whether it was a horizontal flip, we can bring these two
images together. And if they looked like mirror images, then it was flipped horizontally.
This is a kind of a symmetric image. So it's not that obvious, but bring them together
and you can maybe find out the difference. We could also try to flip the image vertically
and horizontally by specifying negative one as a flip code. And the image was flipped
both vertically, as well as horizontally mirror images, but reverse mirror images. And the
last method is cropping now being discussed cropping again, I'm just going to touch on
it, we can create a variable called corrupt and set this equal to IMG and perform some
Array Slicing. So 200 to 403 100 to 400. Save that and run. We didn't display the search.
Even though I'm show it's cool as cropped, past and cropped, Save and Run. And this is
the cropped image we try to bring this together can be brought together, cutting gram holders.
Okay. So that's pretty much it. For this video, we talked about translating an image, rotating
that image, resizing an image, flipping an image and cropping those images, we are basically
just covering the basics, basic image transformations. There are of course, way mo transformation
that you could possibly do with open CV. But just to keep this go simple and beginner friendly,
I'm only covering the basic transformations. So that's it for this video. In the next video,
we're going to be talking about how to identify countries in an image. So if you have any
questions, leave them in the comments below. Otherwise, I'll see you guys in the next video.
Hey everyone, and welcome back to another video. In this video, we're going to be talking
about how to identify contours in open CV. Now contours are basically the boundaries
of objects, the line or curve that joins the continuous points along the boundary of an
object. Now from a mathematical point of view, they're not the same as edges. For the most
part, you can get away with thinking of contours as edges. But from a mathematical point of
view, contours and edges are two different things. contours are useful tools when you
get into shape analysis and object detection and recognition. So in this video, I sort
of want to introduce you to the idea of contours and how to identify them in open CV. So the
first thing I've done is I've read in a file, an image file, and I've displayed that image
using the cv.rm show method. Then next thing I want to do is convert this image to grayscale
by saying gray is equal to CV dot CVT color IMG CV dot color on this go BGR to great,
and we can display this. So just know that we're on the same footing. I'm going to run
this Python, Cantu's down p y. And we get a gray image over here. Now after this, I
want to essentially grab the edges of the image using the canny edge detector. So I'm
going to say Kenny is equal to CV Kenny, we're going to pass in the IMG and we're going to
give it to threshold values. So 125 and 175. And we can display this image calling this
Kenny edges passing Kenny. I save that and run it I didn't save it, save it in ROM and
these are the edges that were there in the image. Now, the way we find the contours of
this image is by using the find contours method. Now this method basically returns two things,
contours and higher keys. And essentially this is equal to CV dot find Cantu's. This
takes in the edges. So Kenny, it takes in a mod in which to find the contents now this
is either CV dot retter on a scope tree, if you want all the hierarchical contours, or
the rhetoric external if you want only the external countries, or, or retter list if
you want all the cartoons in the image. The next method we pass in is actually the cone
to approximation method for now we're going to set this to CV dot chain, unscrew approx
ns go numb. So let's, let's just have a top down look at what this function does. So essentially,
the CBO fund contours method looks at the structuring element or the edges of a found
in the image and returns to values, the contours, which is essentially a Python list of all
the coordinates of the contours that were found in the image. And hierarchies, which
is really out of the scope of this course. But essentially, it refers to the hierarchical
representation of contours. So for example, if you have a rectangle, and inside the rectangle,
if you have a square, and inside of that square, you have a circle. So this hierarchy is essentially
the representation that open CV uses to find these courtrooms. This even retinal list essentially
is a mod in which this fine contries method returns and finds the cuantos. Read a list
essentially returns all the quantities that find in the image. We also have Reto external
that we discussed radix download retrieves only the external conduits to all the ones
on the outside, it returns those revenue underscore tree returns all the hierarchical contours,
all the contours that are in a hierarchical system that is returned by record underscore
tree. For now, I'm just going to set this to will list to return all the contours in
the image. The next one we have is the contour approximation method. This is basically how
we want to approximate the contour. So chain approx none does nothing, it just returns
all of the contracts. Some people prefer to use red chain approx symbol, which essentially
compresses all the quantities that are returned in the simple ones that make most sense. So
for example, if you have a line in an image, if you use chain approx none, you are essentially
going to get all the contours all the coordinates of the points of that line, chain approx simple
essentially takes all of those points of that line, compresses it into the two end points
only. Because that makes the most sense, a line is defined by only two end points, we
don't want all the points in between. That, in a nutshell is what this entire function
is doing. So since cartoons is a list, we can essentially find the number of cartoons
that were found by finding the length of this list. So we can print print length of this
list. And we can say fair, we can say we can say these many contused. Found. Okay,
so let's say that and Ron. And we found 2794 quantos in the image. And this is huge. This
is a lot of code who's ever found in the image. So let's do a couple of things. Let's try
to change this chain approx symbol to chain approx none, and see what that does. See how
that affects our length. Now there isn't any difference between those two, because I'm
guessing that there were no points to compress and sin there are a lot of edges and points
in this image. So there wasn't a lot of compression. So let's change the back to symbol. And actually,
what we want to do is I want to blow this image before I find the edges. So let's do
this. Let's do a blue is equal to CV dot Gaussian Blur can pass in the gray image. And we can
give the kernel size of let's let's do a lot of blur. So five by five. And maybe we can
give it by the default of CV dot border on disko default. And we can if you want to,
and we can display this image, call this blur and pass an error we can find the edges on
this blurred image. So let's close below. And as you can see this significant reduction
in the number of Quorn twos that were found just by blurring the image. So it went all
the way from 2794 to 380. That's closest seven times just by blurring the image with the
kernel size of five by five. Okay, now there is another way of finding the corner shoes
is that it's stead of using this canny edge detector, we can use another function in open
CV, and that is threshold. So I'm just going to comment this out. And down here, what I'm
going to do is I'm going to say, ret Thresh is equal to CV don't threshold, this will
take in the gray image, and we've taken a threshold value of 125 and a maximum value
of 255. I don't worry too much about thresholding. For now, just know that threshold essentially
looks at an image and tries to binarize that image. So if a particular pixel is below 125,
if the density of that pixel is below 125, it's going to be set to zero or blank. If
it is above 125, it is set to white or two by five. That's all it does. And in the find
quantities method, we can essentially pass in the thrush value. So let's save that. Let's
close this out and try to run that. Type. Okay. threshold missing. Okay, I think I forgot
one part, where to specify a threshold and type. So this is CV dot Thresh. On this go,
binary, binary raising the image basically. Okay, let's run that. And there were 839 contours
that were found, we can visualize that let's print ad to display this Thresh. Image, passing
Thresh. Same that run. And this was the thresholded image you're using 125. close this out, using
125 as our threshold value, and 255 as a maximum value, we got this thresholded image. And
when we tried to find the current use on this image, we got 839 concepts. Now don't worry
too much about this thresholding business, we'll discuss this in the advanced section
of this goes more in depth just know that thresholding attempts to binarize an image,
take an image and convert it into binary form that is either zero or black, or white, or
to Vi five. Now what's cool in open CV is that you can actually visualize the contours
that were found on the image by essentially drawing over the image. So what do we do real
quick is actually input NumPy NumPy as NP and after this, I'm going to create a blank
variable and set this equal to NP dot zeros of image dot shape of the first two values,
and maybe give it a data type of I know you are 28 we can display this image because blank
pawsome blank, just to visualize and have a blank image to work with. Let's save that
and go to a blank image. This is of the same dimensions as our original accounts image.
So what I'm going to do is I'm going to draw these contours on that blank image so that
we know what kind of contours that open CV found. So the way we do that is by using the
CV dot draw contours method, it takes in an image to draw over fill blank, it takes in
the contours, which has to be a list, which in this case is just the quantities list.
It takes an account to index which are basically how many countries do you want in the image.
Since we want all of them since we want to draw all of them, we can specify a negative
one, give it a color, let's add this to BGR. So let's set this to red zero comma zero comma
255. And we can give it a thickness of maybe two. And we can display the blank image. So
let's call this contused join. And we can pass in blank. Save that and run. Okay, there
was an error I think this has to be shaped. Okay, so these were the cartoons that would
draw on the image. If you take a look at the threshold value thresholded image, it's not
the same thing. What I believe it attempted to do is instead it found the edges of this
image all the edges of this image and attempted to draw it out on this blank image. Let's
set this so let's set the thickness to maybe one so that we have a crisper view Okay, so
these were the quantities that were drawn in the image. And in fact, if you try to visualize
it with Kenny, let's actually visualize that with Kenny uncomment. That out, run. blows
on the point undefined. Okay, that has to be an image. Okay, let's look at Kenny, let's
look at this. Okay, it's not the same thing. And that makes sense, because our firing coaches
method and use Kenny, as the basis of detecting and finding the controls. But we can do that.
Let's not use a thresholding method. And instead, let's use Kenny. So we can pass in Kenny here.
Save that and run. And, okay, that pretty much the same thing, right? It's basically
a mirror image of these two, like I said, you can get away with thinking of contours
as edges. They're not the same thing. But, but you can think of them as edges. Because
from a programming point of view, they kind of like the edges of the image. Right? The
other boundaries, they are curves that join the points along the boundary, those are basically
edges. So let's try to blow that image. Let's uncomment that out. Let's see what that does.
I don't think that had any effect because we didn't pass in blood. Okay, 380 countries
have found and mirror images of each other. So generally, what I recommend is that you
use scanning method first, and then try to find the corn who's using that, rather than
try to threshold the image and then find the contours on that. Because like we will discuss
in the advanced section, this type of thresholding. The simple thresholding has its disadvantages.
Maybe because we're passing in a simple, just one value, dread binarize the image using
this threshold value, right? It's not the most ideal, but in some cases, in most cases,
it is most favored kind of thresholding because it's the simplest, and it does the job pretty
well. So that's pretty much it. For this video, we talked about how to identify quantities
in open CV. But in two methods first trying to find the edge cascades of the image using
the canny edge detector, and try to find the quantities using that and also trying to binarize
that image using the CV dot threshold and finding the contours on that. So if you have
any questions, leave them in the comments below. I'll be sure to check them out. Otherwise,
as always, I'll see you guys in the next video. Hey, everyone, and welcome back to another
video. We are now at the advanced section of this course, where we are going to discuss
the advanced concepts in open CV. So what we're going to be doing in this video is actually
discussing how to switch between color spaces in urgency. Our color spaces, basically a
space of colors, a system of representing an array of pixel colors. RGB is a kind of
space grayscale is color space. We also have other color spaces like HSV, lamb, and many
more. So let's start off with trying to convert this image to grayscale. So we're going to
convert from a BGR image which is open CV is default way of reading and images. And
we're going to convert that to grayscale. So the way we do that is by saying gray is
equal to CV dot CBT color. We pass in the image and we specify a color code, which is
CV dot color, underscore BGR to to grip since we're converting from a BGR image format to
grayscale format, and we can display this image I st gray and passing in grip. Let's
save that and run Python spaces dot p y. We had a problem as a comma, Save and Run. And
this is the grayscale version of this BGR image. Cool pretty cool. grayscale images
basically show you the distribution of pixel intensities at particular locations of your
image. So let's start off with trying to convert this image to an HSV format. So from Jeff
from vgr to HSV. HSV is also called hue saturation value and is kind of based on how humans think
and conceive of color. So the way we conduct that is by saying HSV is equal to CV dot CBT
color, we pass in the IMG variable. And we specify a color code, which is CV dot color,
undergo BGR to HSV. And we can display the syringe called as HSV and pass in HSV. Let's
save that. And this is the HSE version of this BGR image. As you can see that there
was a lot of green in this era and the skies are reddish. Now we also have another kind
of color space. And that is called the LA be color space. So we're going to convert
from BGR to L A, B. This is sometimes represented as L times A times B, but but v free to use
whatever you want. So lb is equal to CV dot CVT color, we pass the MG and the color on
the scope of BGR. to AB see that I'm sure colas lamb pass and lamb is wrong that and
this is the LGB version of this BGR image. This kind of looks like a washed down version
of this BGR image. But hey, that's the lamb format is more tuned to how humans perceive
color. Now when I started off with this goes, I mentioned that open CV reads in images in
a BGR format that has blue, green and red. And that's not the current system that we
use to represent colors outside of open CV. Outside of open CV, we use the RGB format,
which is kind of like the inverse of the BGR format. Now if you try to display this IMG
image in a Python library that's not open CV, you're probably going to see an inversion
of colors. And we can do there real quick. Let's try to input mat plot lib dot pie plot
as PLT. And we can can, we can basically uncomment commented that out. And we can try and display
this image variable. So we're gonna say PLT dot, I am show pass in the image. And we could
say a peak, or we could say PLT dot show, maybe let's comment this out, save that and
run. And this is the image you get. Now, if you compare with the image that open CV read,
this is completely different, these two are completely different images. And the reason
for this is because this image is a BGR image and open CV displays BGR images. But now if
you tried to take this BGR image and try to display it in matplotlib, for instance, matplotlib
has no idea that this image is a BGR image and displays that image as if it were an RGB
image. So that's why you see an inversion of color. So where there's red over here,
you see a blue, where there's blue over here you see a red, and there are ways to convert
this from BGR to RGB. And that is by using open CV itself. So let's comment that out.
And let's uncomment this all out. And right over here, let's say BGR to RGB. And what
we're going to say is our RGB is equal to CV dot CVT color, we can pass in the BGR image
oopsie, we can pass in the br image. And what we're going to do is specify a color code,
which you see without color on the scope BGR to RGB. And we can try to display this image
in in open CV and see what that displays RGB. And we can also display this in matplotlib.
So I've passed in the RGB. And we can do PLT dot show, save that and go here it is you
Python spaces dot p y. What I'm most interested in is this. And this. Now again, you see an
inversion of colors, but this time in open CV because now you provided open CV and RGB
image. And it assumed it was a BGR image. And that's why there's an inversion of colors.
But we pass in the RGB image to matplotlib and matplotlib is default is RGB. So that's
why I displayed the proper image. So just keep this in mind when you're working with
multiple libraries, including open CV and matplotlib for instance, because do keep in
mind the inversion of colors that tends to take place between these two libraries. So
now another thing that I want to do is we've essentially converted the BGR to grayscale,
we've essentially converted BGR, HSV BGR to RGB BGR to RGB, what we can do is we can do
the inverse of that, we can convert a grayscale image to BGR, we can convert an HSV to BGR,
we can convert an LNB to BGR, and RGB to be GL, and so on. But here's one of the downsides.
You cannot convert grayscale image to HSV directly. If you wanted to do that, what do
you have to do is convert the grayscale to BGR. And then from video to HSV. So we're
gonna do that real quick. So we're gonna say HSV, two BGR. Okay, so the first thing we
do is HSV, underscore vgr. Basically, converting from HSV to BGR is equal to CV dot CVT color,
this will take in the HSV image. And the color code will be color on Cisco HSV, two BGR.
And we can display this image, let's call this HSV, two BGR and pass in HD on the scope
BGR. On screw VR, save that and run. Okay, we're not interested in this. So let's close
this out. But essentially, this is the HSV, two BGR image. If this was the HV image, we
converted this image to BGR. And we can try this with lamb. So let's call this lamb to
lamb, and of course, lamb. And let's copy this and paste that. We can get rid of Mapplethorpe's
it's been addressed in an email. So go out and run. Okay, that was a mistake. We said
HSV, lamb to L baby to BGR. That was my mistake. Cool. So if this was the lamb version, this
is the lamb to BGR version back from BGR to lamb and from lamb to BGR. So that's pretty
much it. For this video, we discussed how to convert, we discussed how to convert between
color spaces from BGR to grayscale, HSV, LGB, and RGB. And if you want to convert from grayscale
to nav, for instance, note that there is no direct method, what you could do is convert
that grayscale to BGR. And then from BGR to and maybe that's possible. By directly. I
don't think there was a way to do that, if open CV could come up with the feature like
that, it would be good, but it's not gonna hurt you to write extra lines of code, at
least two or three lines of code extra, moderately hard. In the next video, we will be talking
about how to split and merge color channels in open CV. If you have any questions, leave
them in the comments below. Otherwise, I'll see you guys in the next video. Everyone and
welcome back to another video. In this video, we're going to be talking about how to split
and merge color channels in open CV. Now, a color image basically consists of multiple
channels, red, green, and blue. All the images you see around you all the BGR or the RGB
images are basically these three color channels merged together. Now open CV allows you to
split an image into its respective color channels. So you can take a BGR image and split it into
blue, green and red components. So that's what we're going to be doing in this video,
we're going to be taking this image of the park that we had seen in previous videos,
and we're going to split that into its three color channels. So the way we do that is by
saying b comma g comma r, which stands for the respective color channels, and set this
equal to CV dot split split of the image. So the CV dot split basically split the image
into blue, green and red. And we can display this image by saying CV dot I'm sure, let's
call this blue and pass in blue. And let's do the same for green image and pass in G
and we can do the same for the red part two are and we can actually visualize the shape
the shapes of these images. So let's first print the image node shape, and then print
the bead on shape. And then print the genome shape and then print the our dot shape. Basically,
we're printing the shapes and dimensions of the image and the blue, green and red and
we're also displaying these images. So let's run Python split merge dot p Why. And these
are the images that you get back. This is the blues, the blue image, this is the green
image. And this is the red image. Now these are depicted and displayed as grayscale images
that show the distribution of pixel intensities. regions where it's lighter showed that there
is a far more concentration of those pixel values and regions where it's darker, represented
a little or even no pixels in that region. So take a look at the blue pick the blue channel
first. And if you can, if you compared with the original image, you will see that the
sky is kind of almost white, this basically shows you that there is a high concentration
of blue in the sky, and not so much in the the trees or the grass, let's take a look
at the green. And there is a fairly even distribution of pixel intensities between the between the
grass, the trees, and some parts of the sky. And take a look at the red color channel.
And you can see that parts of the trees that are red are whiter and the grass in the sky
are not that white in this red image. So this means that there is not much red color in
those regions. Now coming back, let's take a look at the shapes of the image. Now this
stands for the original image, the BGR image, the additional elements in the tuple here
represents the number of color channels, three represents three color channels blue, green,
and red. Now if we proceeded to display the shapes of BG and our components, we don't
see a three in the tuple. That's because the shape of that component is one. It's not mentioned
here, but it is one. That's why when you try to display this image using see even if I'm
show it displays it as a grayscale image, because grayscale images have a shape of one.
Now, let's try and merge these color channels together. So the way we do that is by seeing
the merge image, merged images equal to CV dot merge. And what we do is we pass in a
list of blue of blue comma g comma r, I'd save that in let's display that things either
on show call this them call this the merged image. And we can pass in merged. So let's
save that and run. And we get back the merged image by basically merging the three individual
color channels red, green, and blue. Now there is a way an additional way of looking at the
actual color there is in that channel. So instead of showing you grayscale images, it
shows you the actual color involved. So for the blue image, you get the blue color channel
for the red channel, you get the red color for that channel. And the way we do that is
we actually have to reconstruct the image. The shapes of these images are basically grayscale
images. But what we can do is we can actually create a blank image, a blank image using
NumPy. And essentially, what we're going to do is we're going to say blank is equal to
NP dot zeroes. And we're going to set this to the shape of the image, but only the first
two values. And we can give it a data type of you iemt, eight, eight, which basically
are for images. And to print the blue color channel, what we're going to do is we're going
to say, down here, we're going to say blue is equal to CV dot image, we're going to pass
in the list of b comma, blank comma blink. And we're going to do the same thing for green
and set is equal to CV dot merge of blank comma g comma blank. And we're going to do
the same thing for red by setting this equal to CV dot merge of blank comma blink, comma,
comma red. Basically, what I've done is this blank image basically consists of the height
and the width, not necessarily number of color channels in the image. So by essentially merging
the blue image in its respective compartment, so blue, green and red, we are setting the
green and the red components to black and only displaying the blue channel. And we're
doing the same thing for the green by setting the blue and the red components to black.
And the same thing for red by setting the blue and the green components to black. And
we can display this by saying blue, green, and red. Let's save that and run and now you
actually get the color in its respective color channels. Take a look at this, you now be
able to visualize the distribution much better. Here you can see lineup later portions represent
a high distribution. Lighter portions here represent the high distribution of red and
higher and wider regions represent a high distribution of green. So essentially, if
you take these three images of these color towns and merging them together, you essentially
get back the merged image. That's the merged image. So that's pretty much it. For this
video, we discuss how to split an image into three respective color channels, how to reconstruct
the image to display the actual color involved in that channel, and how to merge those color
channels back into its original image. In the next video, we'll be talking about how
to smooth and blur an image using various blurring techniques. If you have any questions,
leave them in the comments below. Otherwise, I'll see you guys in the next video. Hey,
everyone, and welcome back to another video. In this video, we're gonna address the concepts
of smoothing and blurring in urban CV. Now, before I mentioned that we generally smooth
and image when it tends to have a lot of noise, and noise that's caused from camera sensors
are basically problems in lighting when the image was taken. And we can essentially smooth
out the image or reduce some of the noise by applying some blurring method. Now Previously,
we discussed the Gaussian Blur method, which is kind of one of the most popular methods
in blurring. But generally, you're going to see that Gaussian Blur won't really suit some
of your purposes. And that's why there are many blurring techniques that we have. And
that's what we're going to address in this video. Now, before we actually do that, I
do want to address a couple of concepts. Well, let's actually go to an image and discuss
what exactly goes on when you try to apply blur. So essentially, the first thing that
we need to define is something called a kernel or window. And that is essentially this window
that you draw over an image that has two lines here. Let's draw another line. So this is
essentially a window that you draw over a specific portion of an image. And something
happens on the pixels in this window. Let's change it to blue. Yeah. So essentially, this
window has a size, this size is called a kernel size. Now kernel size is basically the number
of rows and the number of columns. So over here, we have three columns and three rows.
So the kernel size for this is three by three. Now, essentially, what happens here is that
we have multiple methods to apply some blue. So essentially, blur is applied to the middle
pixel as a result of the pixels around it, also called the surrounding pixels. Let's
change that to a different color. So something happens here as a result of the pixels around
the surrounding pixels. So with that in mind, let's go back and discuss the first method
of blurring which is averaging. So essentially, averaging is we define a kernel window over
a specific portion of an image, this window will essentially compute the pixel intensity
of the middle pixel of the true center as the average of the surrounding pixel intensities.
So if this was to green, suppose if this pixel intensity was one, this was maybe two, this
is 345678, you get the point. Essentially, the new pixel intensity for this region will
be the average of all the surrounding pixel intensity. So that's summing up one plus two
plus three plus four plus five plus six plus seven plus eight, and dividing that by eight,
which is essentially the number of surrounding pixels. And we essentially use that result
as the pixel intensity for the middle value, or the true center. And this process happens
throughout the image. So this window basically slides to the right. And once that's done,
it slides down, and computed basically for all the pixels in the image. So let's try
to apply and see what this does. So what we're going to do is we're going to say average,
is equal to CV don't blur. The CV or blow method is a method in which we can apply averaging
blur. So we define the source image which is IMG, we give it a kernel size of let's
say three by three. And that's it. We can display this image called as average, average
blur. Save that and run Python smoothing dot p y net Gosh, we have to pass an average,
save that and run. And this is basically the average blow that's applied. So what the algorithm
did in the background was essentially define a candle window of a specified size three
by three. And it computed the center value for a pixel using the average of all the surrounding
pixel intensities. And the result of that is we get a blurred image. So the higher kernel
size we specified, the more blur there is going to be in the image. So let's increase
that to seven by seven and see what that does. And we get an image with way more blur. So
let's move on to the next method, which is the Gaussian Blur. So Gaussian basically does
the same thing as averaging, except that instead of computing the average of all of this running
pixel intensity, each running pixel is given a particular weight. And essentially, the
average of the products of those weights gives you the value for the true center. Now using
this method, you tend to get less blurring than compared to the averaging method. But
the Gaussian Blur is more natural as compared to averaging. So let's print that out. Let's
call this Yes. And set this equal to CV dot Gaussian Blur. And this will take in the source
image, so IMG kernel size of seven by seven, just to compare with the averaging. And another
parameter that we need to specify is sigma x, or basically the standard deviation in
the x direction, which for now, just going to set as zero. And we can put that out, call
this Gaussian Blur and pass in gaps, save that and run. If you can bear with this, you
see that both of them use the same code size, but this is less blurred as compared to the
average method. And the reason for this is because a certain weight value was added when
computing the blur. Okay, so let's move on to the next method. And that is median blur.
So let's go back to our image. And medium blurring is basically the same thing as averaging,
except that instead of finding the average of the surrounding pixels, it finds the median
of the surrounding pixels. Generally, medium blurring tends to be more effective in reducing
noise in an image as compared to averaging and even Gaussian Blur. And it's pretty good
at removing some salt and pepper noise that may exist in the image. In general, people
tend to use this image in advanced computer vision projects that tend to depend on the
reduction of substantial amount of noise. So let's go back here. And the way we apply
the blur is by saying, let's call this median and set the Z and set this equal to CV dot
median, blue, we pass in the source image, and this kernel size will not be a tuple of
three by three, but instead, just an integer to three. And the reason for this is because
open CV automatically assumes that this kernel size will be a three by three, just based
off this integer. And we can print this out. Let's call this median, blue, and pass in
median. And let's compare it with that. So I set that to seven. And comparing it with
Gaussian Blur, and averaging blur, you tend to look at this. And you can make up some
differences between the two images. So it's like as if this was your painting, and it
was still drawing. And you take something and smudge over the image and you get something
like this. Now generally, medium blurring is not meant for high Colonel sizes like seven
or even five in some cases, and it's more effective in reducing some of the noise in
the image. So let's, let's change this all to three by three. Let's copy that, change
that to three by three. And we can change that to three. And now let's have a comparison
between the three. This is your Gaussian below. This is your average in blue, this is your
median love. So compared with these two, you can see that there is kind of less blurring
when Gaussian when you can sort of make out the differences between the two Very subtle,
but there are a couple of differences between the two. Finally, the last method we're going
to discuss is bilateral blurring caused by natural lateral. Now bilateral bearing is
the most effective, and sometimes used in a lot of advanced computer vision projects,
essentially because of how it blurs. Now traditional blurring methods basically blur the image
without looking at whether you're, whether you're reducing edges in the image or not.
bilateral blurring applies blurring but retains the edges in the image. So you have a blurred
image, but you get to retain the edges as well. So let's call this bilateral and multilateral
and set this equal to CV dot bilateral filter. And we pass in the image, we give it a diameter
of the pixel neighborhood. Now notice this isn't a kernel size, but in fact, a diameter.
So let's set this to five for now, give it a sigma color, which is basically the color
sigma sigma color, a larger value for this color sigma means that there are more colors
in the neighborhood, that will be considered when the blue is computed. So let's set this
to 15. For now. And sigma space is basically your space sigma. larger values of this space,
sigma means that pixels further out from the central pixel will influence the blurring
calculation. So let's set this to 50. So let's take a look at that sigma spacing. So for
example, in bilateral filtering, if this is the value for this central pixel, or the true
center is being computed, by giving a larger values for the Sigma space, you essentially
are indicating that whether you want pixels from this far away, or maybe this far away,
or even this far away from influencing this particular calculation. So if you give like
a really huge numbers, then probably a pixel in this region might influence the computation
of this pixel value. So let's set this to 15. For now, and let's display this image.
So call the cv.on show is called as bilateral and pass on bilateral. Let's save that and
run. And this is your bilateral image. So let's compare with all the previous ones that
we had. Compared with this. Much better compared with averaging way much better. Let's compare
with median. The edges are slightly, it's slightly blurred. If you compare with the
original image, they kind of look the same thing. Okay, it kind of looks like there's
no blur applied. So maybe let's increase this diameter to I know 10. And not much was done,
the edges are still there, it kind of looks like the original image itself. So let's try
into one of the other parameters. Let's add this to 3435. Let's set this dude 25. We're
only playing around with these with these values. And now you can basically make our
generic that this is starting to look a lot like median blow. We need even larger values.
It's starting to show you that this is more looking like a smudged painting version of
this image, right, there's a lot of blur applied here, but the council looking smudged. So
definitely keep that in mind when you are trying to apply blurring the image, especially
with the bilateral and median lowering, because higher values of this basic mouth or bilateral
or the kernel size for medium glowing, and you tend to end up with a washed up smudged
version of this image. So definitely keep that in mind. But that kind of summarizes
whatever we we've done in this video, we discussed averaging, Gaussian, median and bilateral
blurring. So in the next video, we'll be talking about bitwise operators in open CV. So again,
like always, if you have any questions, leave them in the comments below. Otherwise, I'll
see you guys in the next video. Hey everyone, and welcome back to another video. In this
video we're gonna be talking about bitwise operators in urban CV. Now, there are four
basic bitwise operators and or XOR and not. If you've ever taken an introductory CS course,
you will probably find these terms familiar bitwise operators, and they are in fact used
a lot in image processing, especially when we're working with masks like we'll do in
the next video. So at a very high level bitwise operators operate in a binary manner. So a
pixel is turned off if it has a value of zero, and is turned on if it has a value of one.
So let's actually go ahead and try to import NumPy as NP. And what I'm going to do is I'm
going to create a blank variable and set this equal to NP dot zeros of size 400 by 400.
And we can give it a datatype of you I empty it is what I'm going to do is I'm going to
use this blank variable as a basis to draw a rectangle and draw a circle. So I'm going
to say return angle is equal to CV dot rectangle, we can say blink dot copy. And we can pass
in the starting point. So let's give it a margin of around 30 pixels on either side.
So we're going to start from 30, comma 30. And we can go all the way across to 370370.
And we can give it a color. Since this is not a color image, but rather binary image,
we can just give it one parameter, so 255. White, and give it a thickness of negative
one, because we want to fill this image. And then I'm going to create another circle variable
and set this equal to CV dot circle, we're going to say blank, don't copy, we are going
to give it a center. So the center will be the absolute center, so 200 by 200. And let's
give it a radius of give a radius of 200. And give it a color up to five, five, and
let's fill in the circle. So negative one. So let's display this image and see what we've
seen or we're working with. So we'll call this rectangle and passing the rectangle.
And we're going to do the same thing with the circle, it's called a circle. And pass
in the circle, save that and run Python bitwise r p y. So we have two images that we're going
to work with this image of rectangle, and this image of a circle. So let's start off
with the first basic bitwise operator, and that is bitwise. And so before we actually
discuss what bitwise ad really is, let me show you what it does. So essentially, what
I'm going to do is I want to say bitwise is go and is equal to CV dot bitwise. And, and
basically what I have to do is pass in two source images that are these two images, rectangle,
and circle. Now we can display this image, let's call this beautiful lines, and let's
pass in bitcoins and save, run. And essentially, you get back this image. So essentially, what
bitwise AND did was it took these two images, placed them on top of each other, and basically
returned the intersection. Right, and you can make out when you take this image, put
it over this image, you have some triangles that are common to both of these images. And
so those are set to black zero, while the common regions are returned. So the next one
is basically bitwise. Or now bitwise, or real simply returns both the intersecting as well
as the non intersecting regions. So let's try this bitwise OR is equal to CB dot bitwise
AND scope or you pass in rectangle, we pass in circle. Now we can print that, let's call
this bitwise OR pass in bitwise. Oops, that was or save that and run and bitwise OR, okay,
there's a bitwise OR, by mistake. It's a bitwise OR basically return this funky looking this
funky looking shape. Essentially what it did is it took these two images, put them over
each other from the common regions and also found regions that are not common to both
of these images and basically superimpose them. So, basically, you can just put them
together and find the resulting shape and this is what you get, but this image over
this and you get this moving on. The next one is bitwise XOR, which basically is good
for returning the non intersecting regions. So this found the the intersecting oops, the
inter setting regions this found the sky Brought back, the no one intersecting in interest
selecting regions, and xR only finds the non intersecting regions. So let's do that I say
bitwise call this XOR is equal to CV dot bitwise underscore xR, we pass in the rectangle, passing
the rectangle when we pass in the circle, we can display this CV and I'm sure close
bitwise XOR. And we can pass in bitwise XOR. Save that and run. And here we have the non
intersecting regions of these two images when you put them over each other. Pretty cool.
And just to recap, this bitwise AND AGAIN, returns the intersection regions bitwise,
or returns the knowledge second regions as well as the intersecting regions bitwise XOR,
returns the knowledge second regions. So essentially, if you take this bitwise XOR, and subtract
it from bitwise, or you get bitwise end. And conversely, if you subtract bitwise, and from
the device, or you get bitwise XOR. Just so essentially, that's a good way of visualizing
what exactly happens with these bitcoins operators. And finally, the last method we can discuss
is bitwise. Not essentially, it doesn't return anything. What it does is it inverts the binary
color. So let's do that. So let's call this bitwise. Not is equal to CV dot bitwise. underscore
not. And this only takes in one source image. So let's set this to the rectangle put out.
And we can display this. Let's call this rec tangle not, we can pass in bitwise not see
that. And basically what it did is if you look at this image, it found all the white
regions, all the white pixels in the image and inverted them to black and all the black
images it inverted to white, essentially, it converted the white to black and from the
ads from black to white. So we can try that with the circle. Let's call this circle, we
can pass in the circle here. Save and Run and the resultant the resulting circle, not
that you get is this. This is white hole. This is a black hole for physicists out there.
Okay, so that's pretty much it. For this video, I just wanted to introduce you all to the
idea of bitwise operations and how it works. In the next video, we'll be actually talking
about how to use these bitwise operations in a concept called masking. So if you have
any questions, leave them in the comments below. Otherwise, I'll see you guys in the
next video. Hey, everyone, and welcome back. In this video, we're going to be talking about
masking in open CV. Now in the previous video, we discussed bitwise operations. And using
those bitwise operations, we can essentially perform masking in open CV masking essentially
allows us to focus on certain parts of an image that we'd like to focus on. So for example,
if you have an image of people in it, and if you're interested in focusing on the faces
of those people, you could essentially apply masking and essentially mask over the people's
faces and remove all the unwanted parts of the image. So that's basically our high level
intuition behind this. So let's actually see how this works in open CV. So I basically
read in a file and display that image. The other thing I'm going to do is I'm going to
import NumPy NumPy as NP, what I'm going to do is I'm going to say blank is equal to NP
dot zeros of size of size image dot shape with the first two values. Now this is extremely
important, the dimensions of the mask have to be the same size as that of the image.
If it isn't, it's on good work. And we can give it a data type of UI eight, you can see
it if you want to display this, we can display this. It's just going to be a black image,
schools blank image and pawson blank. Essentially, what I'm going to do is I'm going to draw
a circle over this blank image and call that my mask. So I'm going to say mask is equal
to CV dot circle. We're going to draw the blank image on the blank image, we can give
it a center of this image so let's say image dot shape of Have one divided by two divided
by two, and image down shape of two image a shape of zero divided by divided by two.
And we can give it a radius of, I don't know, I'd say 100 pixels, give it a color of 255,
give it a thickness of negative one. And we can visualize a mask as mask and passing mask.
So let's run that. Python masking dot p y. And this is essentially our mask. There's
the blank image we're working with. And this is the image that we want to mask over. So
let's actually create a masked image, we're going to say masked image is equal to CV dot
bitwise. underscore and this source image. So IMG, IMG, and we specify the parameter
mask is equal to mask, which is this circle image over here. And we can display this image,
call this masked image. And we can pass in masked, save that and run. And this is essentially
your masked image, you took this image, you took this image, you put this image over and
found the intersecting region. Okay, by optionally passing the mask is equal to mask. That's
exactly what we're doing. Cool. That's right. And, you know, play around with this, let's
maybe move this by a couple of pixels around, let's say 45. Save and Run moves down to zero,
okay, this has to be 45 plus 45, save up and running. And we get the image of the cat,
we can draw, we can draw a circle, or we can draw a rectangle instead. What's bottom blank,
skip that. Let's give you that in draw, give it a static endpoint of let's copy this and
add a couple of pixels or maybe 100 pixels this way, in 100 pixels. This way, we can
get rid of this, we don't need that and say that, right? This is this, this is the square.
And this is essentially the masked image. So let's actually try this with. So let's
actually try this with a different image. So we have got an image. Let's try it with
maybe these cats too. Let's go back to cats to save that run. And this is the mask that
we get by putting these two on each other. And essentially, you can play around with
these as you feel fit. You can maybe try different shapes, weird shapes. And the way you can
do get these weird shapes, essentially creating a circle or rectangle and applying bid wise
and you get this weird shape. And then you can use that weird shape as your mask. So
let's just try that. Let's let's try that. Oh, we're going to say let's, let's call this
circle and blanked out copy copy and create a rectangle. Let's just grab it from this
re read Where are we from bitvise Let's grab this rectangle copy that piece over time the
copy 3030 Okay, blank, same shape. So let's create this weird weird shape is equal to
CV dot bitcoins on the scope end of this circle this rectangle and we don't need to specify
anything else. um what's one of visualizes let's close this out try to see see it on
on show call this the weird shape passing the weird shape and wrong. masking undefined
was mask westmar Mosque Okay. Good. This is the weird shape that we get. We're not really
going for a half moon But hey, whatever. Let's close this out. Use this weird shape is mask.
So use weird shape as a mask and let's see the final mask image and this is essentially
your weird weird shape, masked image. Let's call this a weird shape mask image, weird
shaped mask damage. This little halfmoon here. And essentially you can, you can do pretty
much anything you want with this, you can experiment with various shapes and sizes and
stuff like that. But just know that the size of your mask has to be at the same dimensions
as that of your image. If you want to see why not maybe subtract 100 pixels possible,
but let's support it, though. So that's maybe like subtract tubal on it. I don't know whether
that'll work. But guess what? Okay, so let's just say, image on shape of while I'm okay,
let's just give it a different size. What are we? Why are we even using image, let's
go this size of 300 by 300. Definitely not the size of this. And we get this assertion
failed m time, blah, blah, blah, maskhadov, same size, in function, whatever. So essentially,
these need to be at the same size, otherwise, it's going to fail and throw you an error.
So that's it for this video, we talked about masking, again, nothing to do different. We've
essentially used the concept of bitcoins and from the previous video, and you will see
that when we move on to computing histograms in the next video, where masking really comes
into play, and how masking really affects your histograms. So if you have any questions
again, leave them in the comments below. Otherwise, I'll see you in the next video. Hey, everyone,
and welcome back to another video. In this video, we're going to be talking about computing
histograms in open CV. Now histograms basically allow you to visualize the distribution of
pixel intensities in an image. So whether it's a color image, or whether it's a grayscale
image, you can visualize these pixel intensity distributions with the help of a histogram,
which is kind of like a graph or a plot that will give you a high level intuition of the
pixel distribution in the image. So we can compute a histogram for grayscale images and
compute a histogram for RGB images. So we're gonna start off with computing histograms
for grayscale images. And so let's just convert this image to grayscale is activity don't
CVD color, pass the image and give it a color code of of color underscore BGR. To gray,
it means read this image with gray and passing Great. Now to actually compute the grayscale
histogram. What we need to do is essentially call this gray underscore hist and set this
equal to CV dot calc hist. This method will essentially compute the histogram for the
the image that we pass into. Now this images is a list, so we need to pass in a list of
images. Now since we're only interested in computing a histogram for one image, let's
just pass in the the grayscale image, there thing we have to pass in is the number of
channels which basically specify the index of the channel we want to compute a histogram
for that since we are computing the histogram for a grayscale image, let's wrap this as
a list and pass in zero. The next thing we have to do is provide a mask do we want to
compute a histogram for a specific portion of an image, we will get to this later. But
for now just have this to num. His size is basically the number of bins that we want
to use for computing the histogram. Essentially, when we plot a histogram, I'll talk about
this concept of bins. But essentially, for now, just set this to 256 wrapped as a list.
And that's wrapped out as list. And the next thing I want to do is specify the range of
the range of all possible pixel values. Now for our case, this will be 02256. And that's
it. So to prop this image, let's actually use matplotlib. So import map plot matplotlib.pi
plot as PLT, and then we can instantiate of PLT dot figure, a PLC figure. Let's give it
a tidy, let's call this gray kale histogram. We can essentially give it a label across
the x axis and we're going to call this bins. Let's give this a y label and set this equal
to the number of pixels. The number Have pixels. And that's why label. And finally, we can
plot by saying PLT dot plot the, the grayscale histogram. And Valley, we can essentially
give it a limit across the x axis. So PLT dot x Lim have a list of 02256. And finally,
we can display this image. So PLT dot show, save that and run Python histogram, dot p
y. And this is the distribution of pixels in this image. As you can see, the number
of bins across the x axis basically represent the the intervals of pixel intensities. So
as you can see that there is a peak at this region, this means that this is close to 5060
ish. So this means that in this image, there are close to 4000 pixels that have an intensity
of 60. And as you can see that there's a lot of, there's a lot of peeking in this region,
so between probably 40 to 70, there is a peak of pixel intensities of close to 3000 pixel
intensities in this image. So let's try this with a different image. Let's try this with
a cants. I'm just going to save that and run. And there is a peaking of pixel values in
between 202 25. And this makes sense because most of the image is white. So given that
reason, you can probably deduce that there will be a peak into words white or 255. Five.
So this is essentially computing the grayscale histogram for the entire image, what we can
do is we can essentially create a mask, and then compute the histogram only on that particular
mask. So let's do that. Let's go back to masking. Let's grab this, grab this. Let's go right
up there. I set this to image dot shape of the first two values the sizes of the same.
Let's essentially draw a mask, which will be CV dot circle of all blank. And we can
get the center of image into a shape of one by by divided by two, image doing shape of
zero divided by two over two, give it a radius of 100 pixels, give it a color of 245 give
it a thickness of negative one, we can display a mask let's call this let's call as mask
policy mask. And here's where things get interesting. We can get the grayscale histogram for this
mask. And the way we do that is by setting this mask parameter to mask two instead of
none. We set this to mask and let's see what that does to our histogram MPs and undefined
great. And I couldn't make this kind of made a mistake here. Oh, that's right. This is
the Masters not exactly the Masters is circle. This is a this will be a circle circle. And
essentially we need to mask out the image so we so the way we do that is by creating
a mask and setting this equal to CV dot Bitcoins. bitwise unscored, and we can pass in the grayscale
image the grayscale image, and we can pass in the mask which is equal to circle. Now
we can use that as the mask. So let's display that x Sorry, I made a mistake, but hopefully
things should be fine right now. So this is the mask and this is the histogram computed
for this particular mask. As you can see that there is a peaking of pixel intensity values
in this region. And there are smaller pickings in in these regions down below. Let's try
this with another image. Let's pass in the cats cats to the cats though jpg. This is
our mask and this is the there is a peaking in this image towards 50. Okay, so that was
it for computing grayscale histograms. Let's move on to true To compute a color histogram,
that is to compute a histogram for a color image to an RGB image. So let's call this
color histogram. And the way we do that is, instead of converting this image to grayscale,
let's comment all of this out. We will use a mask later. That's come in all of this out.
There is mask will be for IMG, IMG. And yeah, that's pretty much it. So let's start with
the color histogram. The way we do that is let's define a tuple of colors, and set this
equal to b, then tuple of G, a tuple element of R. And what I'm going to do next is I'm
going to say for our common call in enumerate of colors. What I'm going to do is I'm going
to say hist. So I'm going to plot the histogram by saying CV dot calc hist, we're going to
compute it over the image itself, the channels will be I mean, this eye over here, we're
going to provide a mask of none for now. Give it a his size of 256 and give it a ranges
of 02256. And then let's do a PLT dot plot hist and give it a color equal to call. And
only we can do a PLT dot x Lim of 02202256. And for this purpose, we can essentially grab
this, copy that uncomment this out. And we can do a PLT dot show. So this should work.
We're missing something Oh, no, don't think of him. We're not, we're not computing this
histogram for a mask, or we live there next. But let's save that run. Oh, cool. And let's
close enough, I made a mistake, this is a color histogram shouldn't make much of a difference.
So this is the color histogram that we get for the original image not for a mask. But
in fact, this image. So as you can see that this color image basically computed the plot
for blue channel, the red channel and the green channel as well. So using this, you
can basically make out that there is a peaking of blue pixels that have a pixel intensities
of 30. There's a peaking of red, probably around 50, peaking of green, probably around
8075 to 80. Cool and using this, you can basically make up the distribution of pixel intensities
of all three color channels. So let's try and apply a mask by setting this equal to
mask. Let's see whether we have everything in order. It's a bit more than mass mass,
mass mass mass masks. Masks are not the same size, okay, I finally got the error. So basically,
the mass needs to be a binary format. So instead of passing in this mask, this will actually
be the masked marks image, Regan passes me fat mask, and we can change the circle to
mask. Now this should work without any arrows. And we can change that to masked. Yeah, that's
around that. And now we get the color histogram for this particular mask, I made a mistake
because I use this as my mask to compute the histogram for one channel. The problem was
this masked image was actually a three channels and I attempted to use this s3 channeled mask
to calculate the histogram per channel, which isn't allowed in open CV. So that was my mistake.
What kind of use the wrong variable names so confused, but essentially, this is it,
you're computing the histogram for a particular section of this image. And this is what you
get there is a high peaking of red in this area, high peaking of blue in this era, and
high peaking of greens I'm over here. So essentially, that's it for this video. histograms actually
allow you to analyze the distribution of pixel intensities, whether for a grayscale image
or for a colored image. Now these are really helpful in a lot of advanced computer vision
projects. When you actually trying to analyze the image that you get, and maybe try to equalize
the image so that there's no peeking of pixel values here and there. In the next video,
we'll be talking about how to thresh hold an image and the different types of thresholding.
As always, if you have any questions, leave them in the comments below. Otherwise, I'll
see you guys in the next video. Hey, everyone, and welcome back to another video. In this
video, we're going to be talking about thresholding in open CV. Now, thresholding is a binary
realisation of an image. In general, we want to take an image and convert it to a binary
image that is an image where pixels are either zero or black, or 255, or white. Now, a very
simple example of thresholding would be to take an image and take some particular value
that we're going to call the thresholding value. And compare each pixel of the image
to this threshold of value. If that pixel intensity is less than the threshold value,
we set that pixel intensity to zero. And, and if it is above this threshold value, we
set it to 255, or white. So in this sense, we can essentially create a binary image just
from a regular standalone image. So in this video, we're actually going to talk about
two different types of thresholding, simple thresholding and adaptive thresholding. So
let's start off with simple thresholding. So in essence, what I want to do is, before
I talk about simple thresholding, is I want to convert this BGR image to grayscale. So
I'm going to say gray is equal to CV dot CVT color, we pass in the image, we pass in the
color code, which is vgr. To correct, we can display this image called this gray, we can
pass in great. Cool. So let's start off with the simple thresholding. So essentially to
to apply this this idea of simple thresholding, we essentially use the CV dot threshold function.
Now this function returns a threshold, and Thresh, which is equal to CV dot threshold.
And this in essence takes in the grayscale image, the grayscale image has to be passed
in to this thresholding function, then what we do is we pass in a threshold value. So
let's set this to 150 for now, and we have to specify something called a maximum value.
So if that pixel value is greater than is greater than 150, what do you want to set
it to, in this case, we want to binarize the image. So we set it to 245. And finally, we
can specify a thresholding type. Now this thresholding type is essentially CV dot thrush
underscore binary. And what this does is basically it looks at the image compares each pixel
value to this threshold value. And if it is above this value, it sets it to 255. Otherwise,
it infers that if it falls below, it sets it to zero. So essentially returns two things
trash, which is the thresholded image or the binarized image and threshold, which is essentially
the same value that you passed 150, the same threshold value you pass in, will be returned
to this threshold value. So let's actually display this image. So let's say cv.rm show,
we'll call this threshold. We'll call this simple thresh hold dead, and we can pass in
thrash. So let's save that and run Python thrash. Da p y in this is a thresholded image
that you get. Again, this is nothing too different from when we discussed thresholding in the
in one of the previous videos, but this is essentially what you get. So let's play around
with these threshold values. Let's set this to 100. And let's see what that does. And
as a result, both parts of the image have become white. So and of course, if you give
it a higher value, less parts of the image will be white. So let's set this to 225. And
very few pixels in this thresholded image actually have a pixel intensity of greater
than 225. So what we can do after this is essentially create an inverse thresholded
image. So what we could do is we could essentially copy this and instead of saying Thresh, I'm
going to say thrush underscore inverse, and I'm going to leave everything else the same.
Let's set this to 150. And the same thing here, and instead of passing in the type of
thresholding, I'm going to say CV dot Thresh underscore binary under scope inverse. And
let's call this thresholded inverse. And we can pass in inverse. So let's save that and
run. And this is essentially the inverse of this image, instead of setting pixel intensities
that are greater than 150 to 255, it sets whatever values that are less than 150, to
255. So that's essentially what you get. Right, all the black parts of this image will change
to white, and all the white parts of the image will change to black. Cool. So that's a simple
threshold. Let's move on now to adaptive threshold data thresholds. Now, as you can imagine,
we got different images, when we provided different threshold values. Now, kind of one
of the downsides to this is that we have to manually specify a specific threshold value.
Now, some cases this might work, in more advanced cases, this will not work. So one of the things
we could do is we could essentially let the computer find the optimal threshold value
by itself. And using that value that refines it binary rises over the image. So that's
an essence the entire crux of adaptive thresholding. So let's set up a variable called adaptive
on its growth Thresh. And set this equal to CV dot adaptive threshold. And inside I want
to pass in a source image. So let's set this to gray, I'm going to pass in a maximum value,
which is 255. Now notice there is no threshold value. adaption method basically tells machine
which method to use when computing the optimal threshold value. So for now, we're just going
to set this to the mean of some neighborhood of pixels. So let's set this to CV dot adaptive
on the scope Thresh. And score mean underscore C. Next, we'll set up a threshold type. This
is CV dot Thresh. underscore binary, which again, I think do different from this from
the first example. And two other parameters that I want to specify is the block size,
which is essentially the neighborhood size of the kernel size, which open CV needs to
use to essentially compute mean to find the optimal threshold value. So for now, let's
set this to 11. And finally, the last method we have to specify is the c value. Now this
c value is essentially an integer that is subtracted from the mean, allowing us to essentially
fine tune our threshold. So again, don't worry too much about this, you can set this to zero.
But for now, let's set this to three. And finally, once that's done, we can go ahead
and try to display this image. So let's call this adaptive thresholding. And we can pass
in adaptive cash. So let's save that and run. And this is essentially your adaptive thresholding
method. So essentially, what we've done is we've defined a kernel size or window that
is drawn of this image. In our case, this is 11 by 11. And so what open CV does is it
essentially computes a mean over those neighborhood pixels, and finds the optimal threshold value
for that specific part. And then it slides over to the right, and it slides, it does
the same thing. And it's lines down and does the same thing so that it essentially slides
over every part of the image. So that's how adaptive thresholding works. If you wanted
to fine tune this, we could change this to a threshold, just go binary and scope inverse,
you're just to see what's really going on under the hood. Cool. So all the white parts
of the image will change the black and all black parts of the image have changed white.
So let's play around with these values. Let's set this to probably 13 and see what that
does. Okay, definitely some difference from the previous hyper parameter. So let's try
it. Let's go with let's set this to 11. And let's set this to maybe one. Okay, definitely
more white. Let's set this to maybe five in a row that you can play around with these
values, right, the more you subtract from the mean, the more accurate it is, right,
you can basically make out the edges now in this basket. So let's maybe increase that
to nine. And you get less white spots in the image. But essentially, now you can make the
features better. Cool. So that was essentially adaptive thresholding, adaptive thresholding
that essentially can Did the optimal threshold value on the basis of the mean? Now we don't
have to stick with the mean, we can go with something else. So instead of mean, let's
set this to Gaussian. So let's save that and see what that does. And this is the thresholded
image using the Gaussian method. So the only difference that Gaussian applied was essentially
add a weight to each pixel value, and computed the mean across those pixels. So that's why
we were able to get a better image than when we use the mean. But essentially, the adaptive
thresholding mean works. In some cases, the Gaussian works in other cases, there's no
real one size fits all. So really play around with these values, see what you get. But that's
essentially all we have to discuss. For this video, we talked about two different types
of thresholding, simple thresholding and adaptive thresholding. In simple thresholding, we have
to manually specify a threshold value. And in adaptive thresholding, open CV does that
for us using a specific block size, or current size and other computing the threshold of
value on the basis of the mean, or on the basis of the Gaussian distribution. So in
the next video, the last video in the advanced section of this goes, we're going to be discussing
how to compute gradients and edges in an image. So if you have any questions, leave them in
the comments below. I'll be sure to check them out. Otherwise, I'll see you guys in
the next video. Thanks for watching, everyone, and welcome back to another video. In this
video, we're going to be talking about gradients and edge detection in urban CV. Now, you could
think of gradients as these edge like regions that are present in an image. Now, they're
not the same thing gradients and edges are completely different things from a mathematical
point of view. But you can pretty much get away with thinking of gradients as edges from
a programming perspective only. So essentially, in the previous videos, we've discussed the
canny edge detector, which is essentially kind of an advanced edge detection algorithm.
That is essentially a multi step process. But in this video, we're going to be talking
about two other ways to compute edges in an image. And that is the lat placing and the
Sobel method. So let's start off with the left place here. So the first thing I want
to do is I want to convert this image to grayscale, recalling the CVT. DVD to color color method,
we pass in the image, and we say CV color on describe BGR to grip, we can display this
image is called as gray. And we can pass in every pass. Great. So let's start with the
Laplacian. So we're going to define a variable called lap and set this equal to CV dot lap
lesion. And what this essentially will do is it will take in a source image, which is
great now, and it will take in something called a D depth or data depth. Now for now when
we set this to CV dot 64, F is for long with whatever I do next, I'm going to say lap is
equal to NP dot u 98. And instead I'm going to pass an NP dot absolute. And we can pass
in lap. And since I'm using NumPy, I can actually go ahead and import NumPy as NP and when I
go to display this image coil CV dot I'm sure method is called this lamp lesion. And we
can pass on lap lap Save and run a call this Python good radians dot p y invalid syntax
CV dot Okay, it's cv.cv on score 64 F. Say that. And this is essentially the law placing
edges in the image kind of looks like an image that is drawn over a chalkboard and then smudge
just a bit. But anyway, this is the lab laser method. Let's try this with another image.
Let's try this with this park called Boston. Let's call this the park. Save that in right.
And this essentially looks like a pencil shading off this image. It's all the edges that exists
in the image, or at least most of the edges in the image are essentially drawn over with
the pencil and then lightly submerged. So that's essentially the left lacing edges you
could say. So again, don't worry too much about why we converted this to in the UI and
then we computed the absolute value. But essentially the Laplacian method computes the gradients
of this image the grayscale image. Generally this involves a lot of mathematics but Essentially,
when you transition from black to white and white to black, that's considered a positive
and a negative slope. Now, images itself cannot have negative pixel values. So what we do
is we essentially compute the absolute value of that image. So all the pixel values of
the image are converted to the absolute values. And then we convert that to a UI 28 to an
image specific datatype. So that's basically the crux of what's going on right over here.
So let's move on to the next one. And that is the subtle gradient magnitude representation.
So essentially, the way this does is that Sobel computes the gradients in two directions,
the x and y. So we're gonna say sobble x, which is the gradients that are computed along
the x axis, and Seth is equal to CV dot Sobel. And we can pass in the image, let's add this
to the grayscale image, we pass in a data depth, which is cv.cv on school 64 F. And
we can give it an x direction. So let's set this to one and the y direction, we can set
that to zero. And let's copy this and call it soble. Why, and instead of one,
zero, we can save zero comma one. And we can visualize this let's print. Let's call this
symbol x, and we can pass in sub x. And we can say it's either long show Sabo y and set
this to Sabo y. Call that and these are essentially the gradients that are computed, this is over
the y axis. So you can see a lot of y horizontal specific gradients and the sub x was computed
across the y axis. So you can see y axis specific gradients. Now we can essentially get the
combined Sobel image by essentially combining these two Sobel x and Sobel why, and the way
we do that is we're gonna say combined on combined underscore sobald and set this equal
to CV dot bitwise. on school or, and we can pass in Sabo x and symbol y. And we can display
this image, so let's call CV dot I'm show we get to combined Sobel and we can pass in
the combined symbol. Let's run that. And this is essentially the combined sobble that you
get. It isn't, let's go back here. So it essentially took these two apply and CV dot bitwise OR,
and essentially got this image. So if you want to compare this with lat race in two
completely different algorithms, so the results you get will be completely different. Okay,
so let's compare both of these left patient and the Sobel with the canny edge detector.
So let's go down here. Let's say Kenny is equal to CV, don't, Kenny. And we can pass
in the image. So let's possible a grayscale image. Let's give it to threshold values of
150 and 175. And we're done. Let's display this image. Let's call this Kenny, we can
pass in Kenny. So let's save that. And let's see what that gives us. So let's compare that
with you. So that's essentially it. This is the last place in gradient representation,
which essentially returns kind of this pencil shading version of the image of the edges
in the image, combined several computes the gradients in the X in the y direction. And
we can combine these two with bitwise OR, and Kenny is basically a more advanced algorithm
that actually uses Sobel in one of its stages. Like I mentioned, Kenny is a multi stage process,
and one of its stages is using the symbol method to compute the gradients of the image.
So essentially, you see that the canny edge detector is a more cleaner version of the
edges that can be found in the image. So that's why in most cases, you're going to see the
Kenny used. But in more advanced cases, you're probably going to see a Sobel use a lot. Not
necessarily lap racing. But so definitely. So that's pretty much it for this video. And
in fact, this video concludes the advanced section of this course. Moving on to the next
section, we will be discussing face detection and face recognition in urban see, we're actually
going to touch on using hard cascades To perform some face detection, and face recognition,
we actually have two parts. Face Recognition with open CV is built in face recognizer.
And the second part will be actually building our own deep learning model to essentially
recognize some faces in an image. Again, like always, if you have any questions, leave them
in the comments below. Otherwise, I'll see you guys in the next section. Hey, everyone,
and welcome back to another video. We are now with the last part of this Python and
open CV coasts, where we are going to talk about face detection and face recognition
in open CV. So what we're going to be doing in this video is actually discussing how to
detect faces in urban CV using something called a har cascade. In the next video, we will
talk about how to recognize faces using open CV is built in face recognizer. And after
that, we will be implementing our own deep learning model to recognize during the simpson
counters, we're going to create that from scratch and use open CV for all the pre processing
and displaying of images and stuff like that. So let's get into this video. Now, face detection
is different from face recognition. Face Detection merely detects the presence of a face in an
image, while face recognition involves identifying whose face it is. Now, we'll talk more about
this later on in this course. But essentially, face detection is performed using classifiers.
A classifier is essentially an algorithm that decides whether a given image is positive
or negative, whether a face is present or not. Now classify needs to be trained on 1000s
and 10s, of 1000s of images with and without faces. But fortunately for us, open CV already
comes with a lot of pre trained classifiers that we can use in any program. So essentially,
the two main classifiers that exist today are har cascades, and mo advanced classifiers
core local binary patterns, we're not going to talk about local binary patterns at all
in this course. But essentially the most advanced how cascade classifiers, they're not as prone
to noise in an image as compared to the hard cascades. So I'm currently at the open CVS
GitHub page where they store their whole cascade, there are cascade classifiers. And as you
can see, there are plenty of hard cascades that open CV makes available to the general
public. You have a hard cascade for an eye, fragile cat face, from face default, full
body, your left eye, a Russian license plate, Russian plate number, I think that's the same
thing. How cascade to detect smile, Hawk cascade for detection of the upper body, and things
like that. So feel free to use whatever you want. But in this video, we're going to be
performing face detection. And for this, we're going to use the har cascade underscore frontal
face underscore default dot XML. So when you go ahead and open that, you're going to get
about 33,000 lines of XML code. So all of this. So what do you have to do is essentially,
go to this role button, and you'll get all this raw XML code, all you have to do is click
Ctrl A, or Command D if you're on a Mac, and click Ctrl C, or Command C, and then go to
your VS code or your editor and create a new file. And we're going to call this har unscrew
face dot XML. And inside this, I want to paste in those 33,000 lines of XML code. Go ahead
and save that and our classifier is ready. So we can go ahead and close this out. So
we're going to be using this Hawk cascade classifier to essentially detect faces that
are present in an image. So in this file called face detect, face underscore detected py,
I inputted open CV, I basically read in an image of Lady a person, that is this image
over here. And we can go real quick and display this. So let's run Python face to face on
disco with detect dot p y, and we get an image in a new window. Cool. So let's actually implement
our code. The first thing I want to do is convert this image to grayscale. Now face
detection does not involve skin tone or the colors that are present in the image. These
hard cascades essentially look at an object in an image and using the edges tries to determine
whether it's a face or not. So We really don't need color in our image. And we can go ahead
and convert that to grayscale, TV dot CVT color, passing the image in CV dot color on
BGR. To gray. And we can display this call this gray of color is gray person, we can
pass in our name. Let's save them and run. And we have to pass in the gray. Okay, we
have a blu ray person over here. So let's move on to essentially reading in this har
underscore face dot XML file. So the way we do that is by essentially create a har cascade
variable. So let's set this to her underscore cascade. And we're going to set this equal
to CV dot cascade classifier, in inside, what I essentially want to do is, is parsing the
path to this har to this XML file. That is as simple as saying har en disco face dot
XML. So this cascade classifier class will essentially read in those 33,000 lines of
XML code and store that in a variable called har underscore cascade. So now that we've
read in all har cascade file, let's actually try to detect the face in this image over
here. So what I'm going to do is essentially, say faces on school rect is equal to har underscore
cascade dot detect multi scale, and instead, we're going to pass in the image that we want
to detect based on. So this is great, we're going to pass in a scale factor. Now let's
set this to 1.1. Give it a variable called minimum neighbors, which essentially is a
parameter that specifies the number of neighbors rectangle should have to be called a face.
So let's set this to three for nap. So that's it. That's all we have to do. And essentially,
what this does is this detect multiscale, an instance of the cascade classifier class
will essentially take this image, use these variables called scale factor and minimum
labels to essentially detect a face and return essentially the rectangular coordinates of
that face as a list to faces on the score rec. That's exactly why we are giving it faces
on scope rect rect, to rectangle. So you can essentially print the number of faces that
were found in this image by essentially printing the length of these faces on the score rect
variable. So let's do that. Let's print the number, number of faces found is equal to,
we can pass in the length of faces on school rect. So let's save that and run. And as you
can see that the number of faces that were found one, and that's true, because there's
only one person in this image code. Now utilizing the fact that this faces on school rec is
essentially the rectangular coordinates for the faces that are present in the image, what
we can do is we can essentially looping over this list and essentially grab the coordinates
of those images and draw a rectangle over the detected faces. So let's do that. So the
way we do that is by saying for x comma y comma w comma H, H in faces underscore rect,
what we're going to do is we're going to draw a rectangle CV to a rectangle over the original
image. So IMG give the point one, this point one is essentially x comma y. And point two
is essentially x plus w comma y plus H. Let's give it a color. Let's set this to green.
So zero comma 255 comma zero, give it a thickness of two. And that's it. And we can print this
or we can display this image. So let's set this to detected basis. And we can pass in
OMG. And if you look at this image, you can essentially see the rectangle that was drawn
over this image. So this in essence, is the face that open CV is hard cascades found in
this image. So let's try this with another image. So what I have here are a couple of
people, a couple of other people then image of five people, so we're going to use that
image and try to see how many faces OBG these hard cascades could detect in this image.
So let's set this to group two. We can change that to a group of five people. Save that
close, right people save and run. And I want to point real quick that the number of faces
that we found, were actually seven. Now we know that there are five people in this image.
So let's actually see what open CV thought was face. So we can go real quick. So actually
detected all the faces in this image, all the five people, but it also detected two
other guests a stomach and part of a neck. Now this is to be expected because her cascades
are really sensitive to noise in an image. So if you have something that pretty much
looks like a face, like a neck looks like a face, it has the same structure as the typical
face would have. I don't know why her stomach was recognized as face. But again, this is
to be expected. So one way we can try to minimize the sensitivity to noise is essentially modifying
the scale factor in minimum neighbors. So let's increase the minimum neighbors to maybe
six or seven. Save that in run. In as you can see, now six faces were found. So I guess
by increasing the minimum neighbors parameter, we essentially stopped open open CV from detecting
her stomach as face. So let's try this with another more complex image, a couple of people
in group one. So if I change that to group one, save rock. Now, as you can see that the
number of faces we've never found was six. And we know that this is not six. So let's
actually change this minimum minimum neighbors just a bit. Let's change this first to three
and see how many faces we'll found. Now we got 14. Okay, some people at the back want
chosen because either the faces are not perfectly perpendicular to the camera, or they're wearing
some accessories on the face, for example, eyeglasses. This dude's wearing a hat, this
dude ran on cap, and stuff like that. So let's actually change this to one. And let's see
what that gets us to one. So, Ron, and now we got 19 faces that were found in this image.
So it's about looping through these values by changing these values. by tweaking these
values, you can essentially get a more robust result. But of course by by minimizing these
values, you're essentially making open CV small cascades more prone to noise. That's
the trade off you need to consider. Now, again, hard cascades are not the most effective in
detecting faces, they're popular, but they're not the most advanced, they are probably not
what you would use if you were to build more advanced computer vision projects. I think
for that, dealings face recognizer is more effective and less sensitive to noise than
open CV is our cascades. It stands for your use case hard cascades are most more popular.
They're easy to use, and they require minimal setup. And if you wanted to extend this to
videos, you could all you have to do is essentially detect hot cascades on each individual frame
of a video. Now I'm skipping that because it's pretty self explanatory. So that's pretty
much it. For this video, we discussed how to detect faces in open CV using open CV as
har cascades. In the next video, we will actually talk about how to recognize faces in open
CV using open CV is built in face recognizer. So like always, if you have any questions,
comments, concerns, whatever, leave them in the comments below. Otherwise, I'll see you
in the next video. Hey everyone, and welcome back to another video. In this video, we will
learn how to build a face recognition model in open CV using open CV is built in face
recognizer. Now, on the previous video, we dealt with detecting faces in open CV using
hard cascades. This video will actually cover how to recognize faces in an image. So what
I have you have five folders or five different people. Inside each folder, I have about 20
images of that particular person. So Jerry has 21 images. Anson has 17 Mindy kailyn has
22 Ben Affleck has 14 and so. So what I'm essentially going to do is we're going to
use open CV is built in face recognizer. And we're going to train that right now. So on
all of these images in these five folders, now this is sort of like building a mini sized,
deep learning model, except that we're not going to build any model from scratch, we're
going to use open TVs built in face recognizer, or we're going to do is we're actually going
to pass in these close 90 images. And we're going to train that recognizer on these 90
images. So let's create a new file. And we're going to call this faces ns, go train dog
p y, we're going to input always, we're going to input CV to our CV, and we're going to
import NumPy as NP. So the first thing I want to do is essentially create a list of all
the people in the image. So this is essentially the names of the folders of these particular
people, what you could do is you can manually type those in, or you could essentially create
an empty list. Let's call this P. and we can loop over every folder in this folder, and
let's set this to an Austrian. And we can say P dot append, I, or we can print P. Let's
save that and run Python beaters on skirt on skirt trained on p y. And we get the same
list that we got over here. So that's one way of doing it. And what I'm going to do
next is I'm essentially going to create a variable called dir, and set this equal to
this base folder, that is this folder which has, which contains these five folders of
these people. Cool. So with that done, what we can do is we can essentially create a function
called def create unscrewed train, that will essentially loop over every folder in this
base folder. And inside that folder, it's going to loop over every image and essentially
grab the face in that image and essentially add that to our training set. So our training
set will consist of two lives. The first one is called features, which are essentially
the image arrays of faces. So let's set this to an empty list. And the second list will
be our corresponding labels. So for every face in this features list, what is its corresponding
label, whose face does it belong to, like one image could belong to Ben Affleck, the
second image could belong to elton john, and so on. So let's create a function. So we're
going to say we're going to loop over every person in this people list, we're going to
grab the path for this person, so for every folder in this base folder, going through
each folder and grabbing the path to that folder. So that's essentially as simple as
saying, Oh s dot path dot join the join. And we can, we can join the der with person. And
what I'm going to do is I'm gonna create a labels label variable, and set this equal
to people don't index of person. And now the way inside each folder, we're going to loop
over every image in that folder. So we're going to say for image to image in our stock
list there. In path, we are going to grab the image Park. So we're going to say image,
underscore path is equal to OS dot path dot join. We're going to say join, we're going
to join the PATH variable to the image. Now that we have the path to an image, we're going
to read in that image from this path. So we're going to create a variable called IMG underscore
rain is equal to CV dot m read image on the scope path. We're going to convert this image
to grayscale I think CVT color, pause and IMG. On scope right here we can pass in t
v dot c, CV dot color on the screw BGR to grip. Cool and now now with that done we can
essentially trying to detect the faces in this image. So let's go back to face underscore
detect and grab the whole cascade classifier variable here. Let's paste that there. And
we can create a set of faces on school rect and set this equal to har underscore cascade
dot detect multi scale this will take in the gray image scale factor of 1.1 and add a minimum
neighbors of four. And we can loop over every every face in this face rect. So for for x
comma y comma w comma each in faces rect, we are going to grab the bases region of interest,
and set this equal to and basically crop out the face in the image. So we're going to say
gray, y two y plus h, and x 2x plus W. And now that we have a faces a face region of
interest, we can append that to the features list. And we can append the corresponding
label to the labels list. So we're going to do features dot append, we're going to pass
in faces on scope, or y. And we can do a labels dot append label. This label variable is essentially
the index of this list. Now the idea behind converting a label to numerical values is
essentially reducing the strain that your computer will have, by creating some sort
of mapping between a string and the numerical label. Now the mapping of we are going to
do is essentially the index of that particular list. So let's say that I grab the first image,
which is an image of Ben Affleck, the label for that would be zero, because Ben Affleck
is at the zeroeth index of this people list. Similarly, elton john, an image of elton john
would have a label of one because it is at the second position or the first index in
this people's lists. So that's essentially the idea behind this. Now, with that done,
we can essentially trying to run this and see whether we got any errors or not. And
we can bring the length of the features. So let's say length, length of the features list,
is equal to the length of features. And we can do the same thing. This was copy this
length of the labels list, set this to length of labels. So that shouldn't give us any error.
So let's run that. And we get the length of the features 100 and length of labels 100.
So essentially, what we have 100 faces, and 100 corresponding labels to this faces. So
we don't need this anymore. What we can do is we can essentially use this features and
labels list now that it's appended to train our recognizer on it. So the way we do that
is we instantiate our face recognizer, call this, as the instance of the cv.face.lb p
h face recognizer underscore create class. And this will essentially instantiate the
face right now. Now we can actually train the recognizer on, on the features list, and
the labels and the labels list. So the way we do that is by saying face underscore recognizer
dot train, and we can pass in the features list, and we can pass in the labels list.
And before we actually do that, I do want to convert this features and labels list to
NumPy arrays. So we're going to do so we're going to say, features is equal to NP dot
array of features. And we can say of labels is equal to NP dot array of labels, and save
that and run. OK, data object. So let's add this to the typed object. Horse in detail
type is equal to object. And we can actually print when this is done, so let's say craning
don't. And we can actually go ahead and save this features and labels list. And we're going
to say NP dot save, we're going to call this features.np y, and we can pass in features.
And we can do NP dots, MP dot save labels dot nPy. And we can pass in the labels. So
let's save that and run cool. So essentially, now the face recognizer is trained and we
You can now use this. But the problem here is that if we plan to use this face recognizer
in another file, we'll have to separately and manually repeat this process, this whole
process of adding those images to a list and getting the corresponding labels, and then
converting that to NumPy rays, and then training all over again, what we can do and what open
CV allows us to do is essentially save this trained model so that we can use it in another
file in another directory in another part of the world just by using that particular
YAML source file. So we're going to repeat this process again. But the only change that
I'm going to do is I'm going to say face recognizer dot save. And we're going to give the path
to a YAML source file. So we're going to save face unscrewed trend, dot yamo. So let's repeat
this process, again, trainings down. And now you'll notice that you have face on scope
trained a yamo file in this directory, as well as faces, as well as features that nPy
annal labels dot nPy. So let's actually use this train model to recognize faces in an
image. So let's close this out. And create a new file. And we're going to call this face
on school rec hig nition dot p y. Very simply, we're going to import NumPy as MP and CV to
sc V, we don't need us anymore, because we're not looping over directories, we can essentially
create our har underscore cascade file. So let's do that. Let's go up here, grab this,
we can load our features and label rate using by saying features is equal to NP note load
features.np y. And we can say labels is equal to NP dot load with called as labels.np y.
And we can essentially now read in this face on the scope train that yamo file. So let's
go over here. Let's grab this line. And let's say face recognizer dot read. And we're going
to give it the path to this YAML source file. So face unscrewed face on screw trained dot
yamo. So that's pretty much all we need. Now we need to get the mapping. So let's grab
this list as well. And so that's pretty much all we have to do. So let's create a variable
image that set this to save it out in read, give it a path. Let's create eight. Let's
grab one from this validation and one from this validation. I have one of Ben Affleck.
So let's try this with grab that piece on. And Graham, maybe this image from but I have
a piece out there. And that's a JPG file. And we can convert that image to grayscale
tv.tv t color positive image CV no color, I'm just going to BG BGR to Great. So let's
just play this image. See, Cole is the person on identified person that's patient on the
board. So what we're going to do is we're going to first detect the face in the image.
So the way we do that is by saying faces on underscore rect is equal to r on this go cascade
dot detect multiscale we pass in the gray image, we pass in the scale factor, which
is 1.1 give it a minimum neighbors of foe and we can loop over every face in his faces
on score rect Sue, Sue for x comma y comma w comma H in faces basis on score rect. We
can grab the region of interest to what we're interested in finding your Why two one plus
H and x 2x plus H. And now we can predict using this face recognizer to we get the label
and a confidence value. And we say face recognizer dot predict And we predict on this faces on
scope ROI, let's print. Let's call this label is equal to label with confidence, off color
confidence. And since we're using numerical values, we can probably we can probably say
people off label. Okay. And we can essentially what we can do is we can put some text on
this image just to show us what's really going on, we can put this on the image, we can create
a string, variable of people of label. So the person involved in that image, given an
origin, let's say 10, let's say 20 by 20. Give it a font face of CV dot font, unscrew
Hershey on school complex. Give it a font scale of one point of 1.0 here to color of
zero, comma 255 comma zero and give it a thickness of two. And we can draw a rectangle over the
image over the face. This is we draw this over the image, we give it x to y and x plus
delta t comma y plus H. We give it a color of zero comma two five comma zero, and we
can give it a thickness of two. So with that done, we can find this display this image
called as the detected bass. And we can pass the image. And finally we can do a CV Delta
Wait, key zero. So let's save and see what we get Python. Python face on school record,
Nish. nation dot p y. Cannot be alone in love pickles equals false. Gosh, where's that?
We probably don't need this anymore. So let's come up with that out. there if you wanted
to use these again, you could essentially use MP dot load. Since the data types are
objects, you can basically say allow pickle is equal to true. That's essentially but we're
not going to use it. So let's comment that out. Save. And okay, we get Ben Affleck with
a confidence of 60%. So that's pretty good. 60% is good, given the fact that we only train
this recognizer on 100 images. So let's try this with another image of Ben Affleck, maybe
this image, copy that go right across here. And this again, is Ben Affleck with the confidence
of 94% pretty good. Let's go back. Let's go maybe to an odd person. Let's go to Madonna.
For to grab this. It's a pain rally. But let's change this to Madonna. And let's grab this
person, I'm not sure whether it will detect a face because of the head. But let's face
that anyway. Now this is where you'll find that obon TV's face recognizer built on face
recognizer is not the best. It currently detects it currently detects that this person in the
image is actually Jerry seinfield. And that will be the confidence of 110%. Maybe there's
an error somewhere. I'm not sure why that went to 111. But pretty sure there's an error
somewhere. But essentially, this is where the discrepancies lie. It's not the best so
it's not going to give you accurate results. So let's try this with another image. Let's
go about to maybe share image, copy that piece of paper. Okay, this is Madonna with the confidence
of 96.8% Okay, let's move on to elton john Watson had problems with elton john. Given
the fact that he looked pretty similar to Ben Affleck for some reason. Copy that chain
got to elton john just called john and print that. Okay, elton john with the confidence
of 67% pretty good. Okay, so not bad. This is more accurate than what I predicted. before
filming this video, I did a couple of trial runs, and I got very good results. For example,
elton john was continually detected as Jerry seinfield or Ben Affleck. Madonna was detected
as Ben Affleck, Ben Affleck was detected as Mindy kaylin. Minnie kailyn was detected as
elton john, and a whole bunch of weird results. So I guess that we did something right. I
must have done something wrong in the trial runs. But hey, we get good results. And that's
pretty good. Now, I'm not sure why that gave a confidence of 111%. Maybe there's an error
somewhere with the training sent. But I guess for the most part, you can ignore that. Given
the fact that we get pretty good results. So that's pretty much it. For this video,
we discussed face recognition. In open CV, we essentially build a features list and a
labels list and we train a recognizer on those two lists. And we saved a model as a YAML
source file. In another file, we essentially read in that saved model saved YAML source
file. And we essentially make predictions on an image. And so in the next video, which
will actually be the last video In this course, we will discuss how to build a deep learning
model to detect and classify between 10 Simson characters. So if you have any questions,
comments, concerns, whatever, leave them in the comments below. Otherwise, I'll see you
in the next video. Hey, everyone, and welcome to the last video in this Python and urban
TV cuts. Previously, we've seen how to detect and recognize faces Pioli in open CV, and
the results we got were varied. Now, there are a couple of reasons for that. One is the
fact that we only had 100 images to train the recognizer on. Now, this is a significantly
small number, especially when you're training recognizes and building models. Ideally, you'd
want to have at least a couple of 1000 images per class. The second reason lies in the fact
that we want using a deep learning model. Now as you go deeper into especially computer
vision, you will see that there are very few things that can actually beat a deep learning
model. So that's what we're going to be doing in this video. Building a deep computer vision
model to classify between the sensing characters now generate open CV GS for pre processing
the data that is performing some sort of image normalization, mean subtraction, and things
like that. But in this video, we're going to be building a very simple model. So we're
not going to be using any of those techniques. In fact, we'll only be using the open CV library
to read an image and resize them to a particular size before feeding it into the network. Now,
don't worry if you've never used a built a deep learning model before. But this video
will be using tensor flows implementation of Kara's now I want to keep this video real
simple, just so you have an idea of what really goes on in more advanced computer vision projects.
And carers actually comes with a lot of boilerplate code. So if you've never built a deep learning
model before, don't worry, Cara's will handle that for you. So kind of one of the prerequisites
to building a deep learning model is actually having a GPU. Now GPU is basically a graphical
processing unit that will help speed up the training process of a network. But if you
don't have one, again, don't worry, because we'll be using candle, a platform, which actually
offers free GPUs for us to use. So real simple, before we get started, we need a couple of
packages installed. So if you haven't already installed Sierra at the beginning of this
course, go ahead and do a pip install Sierra. The next package you require is conero. And
this is a package that I built specifically for deep learning models built with Kerris.
And this will actually appear surprisingly useful to you, if you're planning to go deeper
into building deep computer vision models. Now, installing this package on your system
will only make sense if you already have a GPU on your machine. If you don't, then you
can basically skip this part. So we can do a pip install conero. And can our actually
installs TensorFlow by default, so just keep that in mind. So with all the installations
out of the way, let's actually move on to the data that we're going to be using. So
the data set that we're going to be using is the Simpsons character data set that's
available on kaggle. So the So the actual data that we're interested in lies in this
instance on score data set folder. This basically consists of a number of folders with several
images inside each subfolder. So Maggie Simpson has about 12 128 images. Homer Simpson has
about 2200 images. Abraham has about 913 images. So essentially, what we're going to do is
we are going to use these images and feed them into our model to essentially classify
between these characters. So first thing we want to do is go to kaggle.com slash notebooks,
go ahead and create a new notebook. And under Advanced Settings, make sure that the GPU
is selected, since we're going to be using the GPU off of that click Create. And we should
get a notebook. So we're going to rename this to Simpsons. And one thing I want to do is
enable the internet since we're going to be installing a couple of packages over the internet.
So do use the Simpsons character data set in our notebook, you need to go head to add
data search for Simpsons. And the first one by Alec city, I should pop up, go ahead and
click Add. And we can now use this data set inside a notebook. So the first thing I want
to do is we're going to pip install, seer. And now, now the reason why I'm doing this
yet again. Now the reason why I'm doing this, again, is because candle does not come pre
installed with Sierra and conero. Now I did tell her to install it on your machine. And
the reason for that is because y'all can work with it and experiment with. So once that's
done, go ahead to a new cell. And let's import all the packages that we're going to need.
So we're going to input o s, we're going to input seer, we're going to input conero. We're
going to import NumPy. As NP we're going to input CV to add CV, and we're going to input
GC for garbage collection. Then next what we want to do is in basically when building
deep computer vision models, your model expects all your data or your image data to be of
the same size. So since we're working with image data, this size is the image size. So
all the data or the images in our data set will actually have to be resized to a particular
science before we can actually feed that into the network. Now with a lot of experiments,
I found that an image size of 80 by 80 works well, especially for this Simpsons data set.
Okay, the next variable we need is the channels. So how many channels do we want in our image.
And since we do not require color in our image, we're going to set this to one basically grayscale.
To run back. What we need next is we're gonna say car on the scope path is equal to the
base path where all the data where all the actual data lines, and that is in this Simpsons
on a school dataset, this is the base folder for where all our images are stored in. So
we're going to copy this file path. And we're going to paste that in that. Cool. So essentially,
what we're going to be doing now is, we're essentially going to grab the top 10 characters,
which have the most number of images for that class. And the way we're going to do that
is we are going to go through every folder inside the Simpsons underscore data set, get
the number of images that are stored in that data set, store all of that information inside
a dictionary, so that dictionary in descending order, and then grab the first 10 elements,
first n elements in the dictionary, hope that made sense. So what we're going to do is we're
going to say create an empty dictionary. We're going to say for character in our stop list,
der called car path, we are going to say car underscore dict of car is equal to length
of s dot list dir of Oh s dot path dot join. We're going to join the car on a scope pump
with car. So essentially, all that we're doing is we're going through every folder or grabbing
the name of the folder, and we're getting the number of images in that folder. And we're
storing all that information inside the dictionary called car underscore dict. Once that's done,
we can actually sort this dictionary in descending order. Sending order and the way we do that
is with a car unscored dict is equal to car dot SOT unscored dict of car underscore dict.
And we said descending equals to true. And finally, we can print the dictionary that
we get. So this is the dictionary that we have. As you can see, Homer Simpson has the
most number of images at close to 2300. And we go all the way down to Lionel, who has
only three images in the data. So what we're going to do is now that we have this dictionary,
what we're going to do is we are going to grab the names of the first 10 elements in
this dictionary, and store that in a list of characters list. So we're gonna say characters.
So we're gonna say characters is equal to is equal to an empty list. And we're going
to say, for i in car underscore dict. We're going to say characters, dot append, and we're
going to append the name. So we say I have zero. And we say, if count is greater than
or equal to 10, we can break it, we need to specify a count of zero, and increment that
counts. Okay, once that's done, let's print what our characters looks like. So we've essentially
just grabbed the names of the characters. So with that done, we can actually go ahead
and create the training data. And to create a training data is as simple as saying train
is equal to seer dot pre process. From there, we pass in the car on scope, puff, the characters,
the number of channels, the image size, image size, as we say, is shuffle equals true. So
essentially, what this will do is it will go through every folder inside car on the
scope path, which is Simpsons underscore data set. And we'll look at every element inside
characters. So essentially, it is going to look for Homer Simpson, inside the Simpsons
underscore data set, it will find Homer Simpson, whereas Homer Simpson, it even finds Homer
Simpson is going to go through inside that folder, and grab all the images inside that
folder, and essentially add them to our training set. Now, as you may recall, in the previous
video, a training set was essentially a list. Each element in that list was another list
of the imagery and the corresponding label. Now the label that we had was basically the
index of that particular string in the characters list. So that's essentially the same type
of mapping that we're going to use. So Homer Simpson is going to have a label of zero,
Ned will have label of one, Liza will have label of three, and so on. So once that's
done, go ahead and run this. Now, basically, to basically the progress is displayed at
the terminal. If you don't want anything outputted to the terminal, you can basically just set
set the verbosity to zero. But I'm going to leave things just as it is, since there are
a lot of images inside this data set. This may take a while depending on how powerful
your machine is. So that's only took about a minute or so to pre process our data. So
essentially, let's try to so let's essentially try to see how many images there are in this
training set. We do that by saying the length of trip. And we have 13,811 images inside
this training set. So let's actually try to visualize the images that are present in this
dataset. So we're going to import matplotlib.pi plot as PLT, we're going to do a PLT dot bigger.
And we're going to give it and we're going to give it a big size of 30 by 30. Let's do
a plt.im show, we can pass in first. The first element in this training sets are zero and
then zero. And we can give it a color map off gray. And we can display this image. Now
the reason why I'm not using open CV to display this image is because for some reason, open
CV does not display properly in Jupyter Notebook. So that's why we're using matplotlib. So this
is basically the image that we get somebody legible, but to a machine. This is a valid
image. Okay, the next thing we want to do is we want to separate the training set into
the features and labels. Right now. The train That basically is a list of 13,811 lists inside
it. Inside each of that sub lists are two elements, the actual array and the labels
itself. So we're going to separate the feature set, or the arrays and the labels into separate
lists. And the way we do that is by saying feature set and labels is equal to car dot
zip on school train, we are going to separate the training set and give it an image size
of image size. And that's n equals two. So basically, what this is going to do is going
to separate the training set into the feature set and labels and also reshape this feature
set into a four dimensional tensor, so that it can be fed into the model with no restrictions
whatsoever. So go ahead and run that. And once that's done, let's actually try to normalize
the feature sets. So essentially, we are going to normalize the data to be in the range of
to be the range of zero comma one. And the reason for this is because if you normalize
the data, the network will be able to learn the features much faster than, you know, not
normalizing the data. So we're gonna say feature set is equal to square dot normalize, and
when to pass in, peaches set. Now we don't have to normalize the labels. But we do need
to one hot encode them that is convert them from numerical integers to binary class vectors.
And the way we do that is by saying from TensorFlow, del Kara's dot EDU tools input to underscore
categorical. And we can say labels is equal to two categorical, and we get possible labels,
and the number of categories, which is basically the length of this characters list. Cool.
So once that's done, so once that's done, we can actually move ahead and try to create
our training and validation data. Now, don't worry too much if you don't know what these
are. But basically, the model is going to train on the training data and test itself
on the validation data. And we're going to say x underscore train x underscore Val and
y underscore train and y underscore Val is equal to sere dog train, Val split. And we're
going to split the feature set and the labels using a particular validation ratio, which
we're going to set as point two. So that's basically what we're doing, we're splitting
the feature set and labels into into training sets and validation sets with using a particular
validation ratio to 20% of this data will go to the validation set, and 80% will go
to the training set. Okay. Now, just to save on some memory, we can actually remove and
delete some of the variables and we're not going to be using. So we do that by saying
Dell crane, Dale feature sets, do labels, and we can collect this by saying GC dot collect.
Cool. Now moving on, we need to create an image data generator. Now this is basically
an image generator that will essentially synthesize new images from already existing images to
help introduce some randomness to our network and make it perform better. So we're gonna
say data, Gen is equal to can narrow down generators, dot image, data generator. And
this basically instantiates, a very simple image generator from the caros using the Kara's
library. And once it's done, let's create a training generator. By setting this equal
to data Jim, don't float. And we can pass in extra rain and wind rain and give it a
batch size equal to batch size. So let's actually create some variables here. That's set my
batch size to 32. And maybe let's train the network for 20 bucks. So once that's done,
that's wrong bet. So with that done, we can actually proceed to building our model. So
let's call this creating the model. And before making this video, I actually tried and tested
out a couple of models found that one actually provided me with highest level of accuracy.
So that's the same model, the same model architecture that we're going to be using. So we're gonna
say model is equal to conero dot models dot create Simpsons model, we're going to pass
in an image size, which is equal to the image size, we're going to say set the number of
channels equal to the number of channels, we're going to say, we're going to set the
output dimensions to the to 10, which is basically the length of our characters, then we can,
then we can specify a loss, which is equal to binary binary cross entropy. There we get
set a decay of E of e to the negative sixth power, we can set a learning rate equal to
point 001. We can set Oh momentum of point nine, and we can set Nesterov to true. So
this will essentially create the model using the same architecture I built and will actually
compile the model so that we can use it. So go ahead and run this. And we can go ahead
and try to print the summary of this model. And so essentially, what we have is a functional
model, since we're using Kerris as functional API. And this essentially has a bunch of layers,
and about 17 million parameters to drain out. So another thing that I want to do is create
something called a callbacks list. Now this callbacks list will contain something called
a learning rate shedule that will essentially sheduled the learning rate at specific intervals
so that our network can essentially train better. So we're going to say call callbacks
list is equal to learning rate shedule. And we're going to pass in conero.lr on SCO LR
underscore schedule. And since we're using learning where shedule Let's go and input.
So from TensorFlow, Delve, Cara's no callbacks input learning rate schedule. And that should
about do it. So let's actually go ahead and train the model. So we're gonna say training
is equal to model dot fit, we're gonna pass in the train gin, we're going to say, steps
per epoch is equal to the length of X on school train divided by divided by the batch size.
We're going to say epochs, is equal to epochs. We're going to give the validation data validation
data equal to a tuple of x underscore Val, and y underscore Val. And we're going to say
validation steps. Easy Steps is equal to the length of y on school Val, divided by divided
by the batch. batch size. And finally, we can say callbacks, is equal to callbacks,
callbacks on school missed steps per epoch, that steps for epoch. And that should begin
training. And once that is done, we end up with a baseline accuracy of close to 70%.
So here comes the exciting part, we're now going to use open CV to test how good our
model is. So what we're going to do is we're going to use open CV to read in an image at
a particular file path. And we're going to pass that to our network and see what the
model spits out. So let's go ahead and go to this Simpson test set. So let's go ahead
and try to search for all the way down here. Let's look at our characters. Let's just print
that out just to see what characters we trained on. Okay, let's look for Bart Simpson. Probably
bit irritating, but since data sent Okay, we got an image of Bart Simpson. So click
this and random path, got a test path, set this equal to our string. And what we're gonna
do is we're gonna say mg is equal to CV dot m read test on secure path. And, and just
to display this image, we can use PLT dot m show, we can pass the image, pass in the
image and give it a column map of gray. And we can do a PLT dot show. Okay, PLT show.
And okay, so this is an image of Bart Simpson. So what we're going to do is we are going
to create a function called prepare, which will basically prepare our image to be of
the same size and shapes and dimensions as the images we use to prepare the model in.
So this will take in a new image. And what this will do is we'll, we'll convert this
image to grayscale so we're gonna say injury is equal to CV dot, CVT color, and we're gonna
pass in the injury and we're gonna say CV dot color on scrub BGR. To gray, we can resize
it to our image size. So we're going to say mg is equal to CV dot resize, we're going
to resize the image to be image underscore with size, I'm going to reshape this image.
So injury is equal to stare dot reshape, reshape of image. We want to reshape the image to
be of image size with channels equal to one. And we can return image. So let's run that.
And let's go down here. And let's say predictions is equal to model dot predict and prepare
image. And we can visualize this predictions. So let's print predictions. And essentially,
this is what we get. So to print the actual class, what we can do is we can print their
characters, BB NP dot arg Max, and we can say predictions of zero. You're not trying
to visualize this image so we can do a PLT dot m show. Let's pass in the image. And PLT
dot show. Let's grab this and move this down. ver. That's right. Yeah. Okay, so this is
our image. And right now our model thinks that buttons in is in fact, Lisa Simpson.
Let's go. Lisa Simpson. Okay. Let's try another image. Let's try probably this image is Bart
Simpson 28. Let's go up they and maybe change that to two, eight. run that. This is Bart
Simpson. Let's run this. And let's and again, we got Lisa Simpson. So let's try with a different
image. Yeah, we do. We did Charles Montgomery to copy this. All the way down there. We got
Charles predict, and we get van Hughton. Okay, definitely not the best model that we could
have asked for. But hey, this is a model. Right now this base discounting has a baseline
accuracy of 70%. Although I would have liked it to go to at least 85%. In my test, it had
gone close to 90 92%. I'm not sure exactly why this went to 70%. But again, this is to
be expected into building deep computer vision models is a bit of an art. And it takes time
to figure out what's the best model for your project. So that's it for this Python and
open c because this goes to is basically kind of a general introduction to open CV and what
it can do. And of course, we've only just scraped the surface and really this A whole
new world of computer vision now fair. Now, while we obviously can't cover every single
thing that open CV can do, I've tried my best to teach you what's relevant today in computer
vision. And really one of its most interesting parts, building deep learning models, which
is in fact, where the future is self driving vehicles, medical diagnosis, and tons of other
things that computer vision is changing the world. And so all the code and material that
was discussed throughout this course is available on my GitHub page. And the link to this page
will be in the description below. And just before we close, I do want to mention that
although I did recommend you installed Sierra in the beginning, we barely use it throughout
the coasts. Now, it's probably not going to make sense to you right now. But if you plan
to go deeper into computer vision into building computer vision models, Sierra lasher proved
to be a powerful package for you. It has a lot of helper functions to do just about anything.
Now I'm constantly updating this repository. And if you want to contribute to these efforts,
definitely do that you can set a pull request with your changes. And if it's helpful, it
will be merged into the official code base, and you'll be added as a contributor. If you
want to building deep learning models with Kara's then conero will be useful to you.
But again, for the most part, it's usually software that you'll be using. So anyway,
with that said, I think I'll close up this course, if this goes helped you in any way
and God you're more interested in computer vision, then definitely like this video, subscribe
to my channel, as I'll be putting up useful videos on Python computer vision and deep
learning. So I guess that's it. I hope you enjoyed this post and I'll see you in another
video.
