computer vision made easy video -凯发k8网页登录

welcome to the computer vision made easy webinar. my name is sandeep, and i'm in the product marketing team at mathworks. computer vision is used extensively by our customers to solve a wide variety of vision problems in different application areas. for example, in automated driving to design lane departure warning system. and in robotics, to help plan the mars rover.

here, is a simple example of a computer vision-based traffic monitoring system like what you might have noticed when driving past a traffic light. here, a camera-based monitoring system is keeping track of the number of cars in the scene at any given point of time. in this system, computer vision was primarily used to detect, and count the cars in each frame of the light video from the camera. detecting objects like cars in the video is a common computer vision task, but there are many more like them.

so what are some of these common tasks, or problems? well, if you're new to computer vision you might be interested in knowing how do i detect objects in a scene. or how do i measure objects, or regions in an image. or how do i detect objects, or classify an event using deep learning. so in this video, our objective is to help you get started with addressing this common computer vision tasks, or problems. and you will do this through some real world examples using matlab.

so here are the examples that we will cover in the next 30 minutes, or so. so let's get started with our first example. in this example here, i have an image of a cluttered pile of playing cards on the left. and an image of a specific playing card on the right. my objective here is to detect, or locate the specific playing card in the image of a pile of cards. now this might seem like an easy task. however, there are many challenges to solving this problem. the object of interest could appear to be smaller, or larger than the template image. could be rotated, or skewed. or they could be a partially hidden behind other objects. these are some common challenges that you will notice in most object detection problems.

here, you cannot use a standard image processing algorithm like template matching to find this object. you will need a slightly more sophisticated, and robust approach. to solve this problem, i have chosen a very fundamental computer vision workflow called feature detection extraction, and matching. so before we get into understanding this workflow, let's first understand what is a feature. in simple terms, a feature is a distinct region in an image that leads to a unique match in another image. and something that is repeatable across many images. some good examples of features in images are corners, edges, blobs, or maybe a template of an object, or region in the scene itself.

so what is this workflow look like? feature-based object detection workflow involves three main steps. first, to detect interesting features in the template image of the object. and this is shown by the green markers. and you do the same for the other image as well. second, to take a region surrounding the detected features, and encode some information about that region into what you call a feature descriptor. this is called feature extraction, and that is represented by the green circles around the markers. you do this for both the images.

and third, you look for corresponding matches between the extracted features of the two images. and then remove any outliers. once you have a set of match features, you can then estimate the location of the object in the scene. now, let's go to matlab, and see how to solve this problem.

ok, so this is my matlab environment. now, the first thing that i'm going to do is to read the two images that we are working with. one, is the reference image of the card which is the king of hearts card that we are looking for. and second, is the cluttered card image that contains this card. so i'm going to use i am read from the image pricing toolbox to read the two images. and then use i am sure pair to display them next to each other.

so here are my images. as you can see, the king of hearts card and the images card is not exactly in the same orientation, and scale as the reference image. and probably also not in the same reference plane. so a simple image pricing technique like template matching will not work in this case. we need a more robust approach which is to look for features within these images, and compare them to find a match. so in the next section, i will use an algorithm called surf to detect features in these images.

now, surf work specifically on 2d grayscale images. so i have to use rgb to create initially, to convert the color image to grayscale. and then, i've used detect surf features from the computer vision toolbox, and the reference image. this should output the detect feature points for the image. next, i would like to visualize the detected feature points for this image. so here, i've chosen to plot only the strongest 50 points.

so here, is the reference image, and the 50 strongest feature points across the entire image whose locations are represented by crosses. and the circles around these location points represent the scale of the features which should both together are important parts of a feature descriptor. these feature descriptors represent the unique, and interesting information that describe, and differentiate them from other features in the image.

now, surf algorithm defines these features by detecting blobs in this image. blobs are nothing but connected areas in an image with high contrast pixels. in our case, a blob is the heart suit in the card. or the king's eyes are few smaller ones in the character k area. now, like surf there are many other detection algorithms available through the computer vision tool box. like for example, we have fast which is really good at detecting corners in images. so refer to the help documentation to learn more about all these different feature detection algorithms.

now, let's go back to our script, and see what's next. so next, i'm going to detect surf features on the card's image as well. make sure to use the same detection algorithm on both images so that we can make an apples to apples comparison, and matching these features. so let's run this section. and look at this time, 300 of the strongest points on the image. so here, you can see we have feature points in the king of hearts card region, but also across the other cards in the image.

now once we have detected the feature points for this image, next, we are going to extract the feature descriptors which are the region maps around these points. to do that, i'm using the extract features function from the computer vision toolbox. i pass the grayscale image and the detected points from before. and this will give us the feature vectors, and corresponding locations for each image. now, the extraction method used here, depends on the detection algorithm used, which is surf in our case. i have the feature descriptors for both the images now.

next, i need to compare them to find matches. so to do this, i'm going to use match features on the computer vision toolbox which returns the indices of the matching features in the two input feature sets. i can then obtain the corresponding matched feature points for both images, and use show match features to view the matched points. let's run this section, and see the match points across the two images.

as you can see here, match features has found numerous matches in the two images. and also these matches are within the king of hearts region except for a few like these two points here in the jack of spades card. now, notice how there are some feature matches like in the card character region key, to the character in the cards image here. but also to the k in the reverse here. the reason for this, is that surf algorithm is rotation invariant, which means that it will detect matches, and features irrespective of their orientation. and also, irrespective of their scale. this is why features based detectors are much more robust than a simple template matching technique.

now that we have found matches between the two cards, we are not done with the detection problem yet. i need to improve the matches by getting rid of the outliers, including the duplicate matches like to the character k in reverse so that i can find the exact region within the cards image where the king of hearts card is located. for this, i'm going to use the estimate geometric transform function from the computer vision toolbox to compute the transformation matrix that will determine how the reference image has to be geometrically, and spatially transformed so that it best fits within the bounding region of the king of hearts card in the card's image.

this function also returns the inlier points for both images which are obtained by eliminating all the outliers like the ones that we saw in the jack of spades card, using an algorithm called ransac. ransac, or random sample consensus is a mathematical model that uses an iterative approach to estimate inliers by randomly sampling the observation points to find the optimal fitting result. in our case, this being a geometry transformation that will help fit the reference card image to the cluttered card's image. you can learn more about this algorithm by referring to help info for estimate geometric transform function.

now, let's go ahead, and run the section to see the matched features again. but this time, with the outliers' remote. there you go. those outliers, and the jack of spades cards have been removed. and also, notice how some of the other ambiguous matches that we had seen earlier have also been eliminated. and then finally, using the transformation matrix that we obtained earlier, we can go ahead, and transform a rectangle of the dimensions of the reference card image, and call that new box polygon.

and then, use that to enter the card's image to indicate the exact location of the detected card in the cluttered card's image. so here is a final result. now, what we have seen so far is how to detect a card in an image using a reference image. now, what if we wanted to detect the type, or recognize this card? that is, it's a king of hearts card. now, we could have again used feature matching approach to do this. but let's see a more sophisticated approach we will use a trained detection algorithm to perform detection.

with trained detectors instead of using a template to find, and match features, we will use surf-like technique to collect the feature sets from the numerous images of say, the character k. and then, using machine learning model like svm, we will design a detector that can detect that character in other images. since a trained detector has been trained with features from hundreds to thousands of template images, it is a much more robust approach like when detecting objects in varying lighting conditions, or trying to find an object by its class. that is, say, like detecting a car in an image irrespective of its model, or make.

so in our case, let's go ahead and use a train detector to detect the card character by its font inside the detected card. which is, say, the letter k in the king of hearts card. and just so you know, i will do this using the optical character recognition, or ocr algorithm. so let's go ahead, and see how to use this algorithm in matlab. first, we will transform the card's image using fitgeotrans to match the reference image. and we do this so that the image can be spatially adjusted to match the dimensions of the reference image. by doing this, we can then easily extract the character, and suite information in the cards since we know this is always available in the top left region of any card.

so let's go ahead, and de-warp the cards image using the imwarp function, and see the output. so here is the king of hearts card region, and the card's image that has been transformed. next, i need to extract the regions in the card containing the character, and suit, and use the extracted regions to detect each of them individually. to extract these regions, i have a helper function, getcardrois that performs this extraction for me, and returns the regions containing the character, and suit. i'm using the montage command to display both the extracted regions. so let's run this section, and see the output.

here are the extracted regions as two separate sub images. next, i need to identify the character in the first sub image. to do this, i can use the optical character recognition, or ocr algorithm. ocr is a properly used technique to detect, and recognize text within an image. this could be printed, or handwritten texts. in matlab, we have a pre-trained ocr function that is available in the computer vision toolbox. there are multiple fonts that it can detect by default, but it can also be trained to detect custom fonts. so in my script, i am using the ocr function to detect the character in the sub image.

and here, is the output returned by ocr. and as you can see, it has successfully detected the card character as k. next, i need to find the suit type in the second sub image. well for this, i've taken a simpler approach for using template matching. i simply compare this sub image with a set of template images that i have of the four different suits. i'm using the vision.templatematcher system object from the computer vision toolbox to perform template matching. if you wish to learn more about the system object, please go, and find vision.templatematcher in the help documentation.

i run the matching across all the template images within the for loop. here, within the for loop, i read one template image at a time, resize the sub image to match the template image, and then perform template matching. the system object in this case, returns a match metric where the largest metric value corresponds to the best match. so let's run the section, and see what the result for our sub image looks like. as you can see, we have successfully detected the output for template matching these hearts.

one thing to note here, is that template matching is a very rudimentary detection technique which worked well in this particular case. but if the suits were not aligned, scaled equally, or varying in contrast, this would have failed miserably. so for a more complex detection problem, consider using a more robust approach like feature-based detection that we saw earlier. and then finally, we can annotate the card image with the detected card character, and suit names that is king of hearts.

like ocr, there are many other object detectors available in matlab through the computer vision toolbox, which can be used to detect some common objects like bar codes, people, faces, foreground objects in a video, and blogs. some of these detectors can also be trained with your own data to detect other objects of interest. for example, to detect pedestrians in a road scene.

matlab, through the computer vision toolbox, also provides you with a set of ready to use object detectors based on a few popular deep learning networks. in matlab you can also input, and use pre-trained deep learning networks to solve object detection problems. for example, in this video, what we are showing, is a pre-trained network called alexnet that has been trained to detect about 1,000 different object classes. matlab lets you import this popularly used network with a single line of code, and use it within your computer vision application.

there are many deep learning models like alexnet that are used popularly in the research, and commercial field that you could quickly import into matlab, and start using them in your solutions. now, note that you can retrain these networks in matlab with new data to detect other objects of interest. here, is a list of some popularly used deep learning detectors. and also, note that these are available in matlab as ready-to-use functions. one other thing i want to emphasize, is that matlab, in addition to making it easy to apply deep learning to computer vision problems using pre-trained networks, it also provides interactive apps like labeling apps, and deep network designer app that make the whole workflow of free training these networks are designing new networks from scratch a very convenient, and exploitative process.

now, let's move to the second example, which is to measure size of objects in an image. in the example, what i have is an image which is a mix of different kinds, and few other objects. what i would like to do is separate out the kinds in the image, and then determine the total value of all the kinds. for example, if i have two quarters, and one nickel, the total value is $0.55. now, one way to do this, is to determine the different types of kinds in the image based on their size. and then, if i know the true diameter of each coin type, say, a quarter is 24.26 millimeters, i can use both of these pieces of information, and find out how many kinds of each type are in the image.

after that, it is a simple math to calculate the total value of coins in the image. now, to compare the pixel-based dimension in the image, and the actual size, or dimension of an object, we need to compute the size of a pixel in real world units. this factor will help us find the true size of any object, or region within the image. now, there are some challenges to accurately measuring the pixel size in real world units. one major challenge is that distortions due to camera properties could affect making such measurements effectively.

to solve such distortion-related challenges, i'm going to use a camera calibration workflow. calibration allows us to estimate the parameters of properties of the lens, and camera. so what are these camera properties? well, there are intrinsic properties like focal length, optical center, lens distortion, coefficient. and there are extrinsic parameters like position, and orientation of the camera with respect to the object. using the estimated parameters, we can then correct the image taken from that lens for any distortions that might exist.

camera calibration is a very commonly used technique, and many computer vision applications. for example, as a pre-processing step to correct images to remove lens distortion issues, or when trying to build a panoramic view by stitching together multiple images taken by the same lens. or, when estimating the depth, or proximity of an object from the lens especially when using studio vision-based cameras. in our case, we will be primarily focusing on using calibration to remove distortions in the image to help accurately measure the pixel size, and real world units.

now, let's go to matlab, and see how to solve this problem. so here is the image that we'll be working with. as you can see, this image actually has some kinds, and a few other objects in the bottom part of the image. and the top part of the image, we have a checkerboard pattern. so the checkerboard pattern is really essential for two things. one, is to be able to perform camera calibration. and the second, is really to transform this image for orientation, and any other distortions, and skew that might exist in the image.

so let's go ahead with the first step, which is camera calibration. so to perform camera calibration, i'm going to use the camera calibrator app that is available through the computer vision toolbox. to get that, i'm going to the apps tab. and here within the image processing, and computer vision section, i can access the camera calibrator app. let's bring that up.

so the first step within the camera calibrator app, is to bring the images that we are going to be using for the calibration step itself. so to do that, i click on add images. and here, i can select the images that i'm going to be using for my calibration step. in this example, i'm using seven images. but typically, 10 to 20 images are recommended in drill situations. and also here, it asks you for the size of the checkerboard square which it's going to use for the calibration process. i know each square in my checkerboard pattern is about 20 millimeters.

provide that, and then the app goes ahead, and starts looking at the images, and then starts detecting the checkbooks. and then, it provides the detection results. so here, you can see that it has detected checkerboard across all the six, and the seven images. and it says it's going to reject one of the images. so we'll say ok. and then now, it has shown me the six images that it's going to use for the calibration process.

so here are the results. you can see that it has detected the points within the checkerboard pattern in each of these images. now, the next thing that i want to do is to be able to look at some of the options available in the camera calibrator app. the first thing here, is the camera model. i can either pick a standard lens, or a fisheye, or a wide angle lens. in my case, it's a standard lens. so i'm just going to keep this as my default selection.

also, i have options to help me improve my parameter estimation. for that, i have radial distortion coefficients that i can actually choose. radial distortion is typically what you see along the edges of the lens, which is along the optical center. and you would want to correct these distortions specifically for wide angle lenses. you can also compute, skew, and tangential distortions if you choose to. for now, i'm going to keep these options at default. and next, i'm going to hit the calibrate button. this should now go ahead, and start the calibration process, and give me some results.

the first thing that i want to show you here, is the projection errors. as you can see, the reproduction errors are typically calibration errors. we want to make sure that we keep the error values low. so the way to do that is to remove any outliers. and here in this case, the second image of the checkerboard is definitely a little above the overall mean errors. i'm going to choose to remove this, and then re-calibrate with the remaining five images. so now, you can see that i have removed that image, and i have a much better overall mean error, which is about 0.57 pixels. before, it was about 0.63 pixels. it's not very different, but this is the process of trying to improve your calibration results.

after this, i can go ahead, and export camera calibration parameters to the matlab workspace. and the variable that i'm going to save this to is called camera parameters. now, just so you know, if you were to do this camera calibration process manually, it could get really complicated, and ugly. camera calibrator app really helps in making this whole workflow very convenient, and easy without being an expert in the calibration process. it lets you automatically detect the checkerboard points, it lets you work with a different variety of camera models, standard lenses, or right angle lenses. and it also automatically calibrate the images for you, and then makes those results available within the matlab environment to go ahead, and use it for further analysis.

ok. so now that we have completed the camera calibration process, and i have the camera parameters saved as a mat file, we can go ahead, and see how to use the camera parameters to undistort the coin's image. and then, work with this undistorted image for true measurement of coin size. my end goal is to identify the coins based on their sizes, and find the total value of all coins in the image. now, let's look at this image.

so here is the image. as you can see, it contains the coins, and a few other objects in the bottom half of the image. and the checkerboard pattern on the top half. now, the checkerboard pattern is very significant in solving this problem. and we will go over that more in detail later on. this image needs to be corrected, or undistorted using the camera parameters that we obtained from the camera calibration process. this way, the image is free of any distortions before proceeding further. to do that, i'm going to load the camera pair images first, and then use the undistort image function from the computer vision toolbox to correct the image. so let's run the section, and see the output.

in our case, the undistorted image doesn't look very different. but if we had an image that was taken using a wide angle lens, then you'd notice a significant difference after undistortion. next, before i start detecting the coins, and measuring them i must make sure that all the pixels in the image have the same pixel to real world unit factor, which is a very important step towards making accurate measurements across the image. for this, we have to transform the original image using the reference checkerboard pattern since we know it's real world dimensions. this transformation will ensure that the pixel to real world measurements are uniform across the entire image.

now, let's see how this transformation works. i'm going to first determine the checkerboard pattern points using the detect checkerboard points function that is available in the computer vision toolbox. let's display these points in the image. next, using the information i know about the checkerboard pattern, like how many squares along the rows, and along the columns, i can determine the corner points of the detective checkerboard region. then, we'll find the approximate location of the corner in a new plane that would remove any perspective projection that might exist due to the angle of the camera to the plane containing the checkerboard pattern, and coins.

these new kind of points are available to us in a variable called basepts. so let's run the section, and see the base points with respect to the corner points. now, using the base points as a reference, we will find the transformation matrix that we need to project the image on the plane represented by the base points. and we do this using the fitgeotrans function from the image pressing toolbox. this returns a transformation matrix that i can use to de-warp the kinds image using the imwarp function. let's run the section, and see the output.

so here is a transformed image. so this image is now ready for making accurate measurements. now that i have a transformed image containing the coins, the next thing i need to do is to detect the coins in the image, which are nothing but circular objects. so in this section here, i am first converting the transformed image to binary using the imbinarize function. i have a slider here to adjust the threshold value. this way, i can get the desired result from a binary output. and then, i'm using imfindcircles to find circles that comes from the image processing toolbox to find the coins in the image.

as you can see, i have a few parameters here. and i have a slider here again to adjust the sensitivity parameter so that it picks up only the strongest circles that represent the coins in the image. you can learn more about these other parameters of the imfindcircles function by referring to the help info on it. once i have detected the circles, and i know the pixel coordinates of the centers, and the radii, i'm going to use viscircles to display these circular regions on the coins image. so let's run this section, and see the results.

as you can see, the coins have been detected as circles. it missed out on one coin. so i can go back to i am find circles, and increase the sensitivity by adjusting the slider here to make sure that i have all the coins detected. so one thing to note here, is that imfindcircles circles is not a very robust technique for such detection problems. we are assuming here that coins are the only circular objects in the image. also, with waiting light conditions, the detection of circles may not always work well. in that case, we will have to use a more robust approach like using a train detector like we discussed in the card detection example to detect the coins in the image.

so now that we have detected the coin regions in the image, and i know the size of the coins, and pixel values, next, i will have to compute the size of the coins in real world units. to do this, i need to first know what is the pixel to real world units factor which i can then use to compute the real world size that is in millimeters, the radius of the coins. so to do this, i'm going to use again, the checkerboard pattern as my reference. i will detect the checkerboard points like before, and then compute the size of the square in the pattern in pixels. i know that the size of the square of the checkerboard pattern is 20 millimeters. so using that, i can compute the pixel to millimeter factor for this image. so let's run the section, and see the output.

so here is the pixel to millimeter factor using the checkerboard. so now using this pixel to millimeter factor with the coins, sizes and pixel, i can compute the coin sizes in millimeters. like the known size of the square of the checkerboard, we also know the true radii of the coin types in our image. and in our case, these are cents, nickels, and quarters.

so in this next section here, i find the pixel size of the three coin types using the true size values, and the pixel to millimeter factor that we computed earlier. and with this as reference, i can compare them with my pixel values of circles that we obtained earlier from the image. and i can then bend each circle as either a cent, nickel, or quarter.

so here, i first sort the radii of the circles. and then use histogram, which is a matlab function, to bend the circles with the coin pixel sizes as the reference. let's run the section to see the distribution of these circles as these three coin types. you can see in the graph that we have two circles which are binned as cents, three as nickels, and 4 as quarters. i use this histogram function again, to obtain the counts this time, and i display the count. once i have the count of each coin type in the image, i can very easily calculate the total value of the coins in the image. and this is $1.17 which is the actual value of the coins in the image. and this way, we have verified that our coin measurements, and binning actually worked well for this image.

and finally, we can display our final results on the coin's image. notice that i've used viscircles again here, to indicate the different coin types in the image with colored circles. now, what if we had to measure size of an object like a leaf, which doesn't have a very defined shape, and there is no easy way to automate the detection of such an object in the image? in this case, once we know the pixel to mm factor for that image that contains the leaf, we can use imdistline, which lets you to interactively measure the distance between two pixels in the leaf region. and then, you can use that to compute the distance in real world units using the pixel to mm factor.

so here, i have replaced the pixel rating with the computer distance in millimeters. so in a sense, we have seen that if we have a reference like the checkerboard pattern in any image, we can compute the pixel to real world units factor, and use that to measure the true size of any object or region in that image. so what we have seen in matlab, was the camera calibrator app that supports standard, and wide angle lenses. computer vision toolbox provides a separate serial camera calibrator app to help calibrate images taken from a studio camera pair, typically useful in tasks like depth estimation.

so that brings us to this final summary slide. we have seen how getting started can be made easy using matlab for someone new to computer vision. we have seen through some examples-- matlab makes it easy specifically, to detect objects with using readily available feature, and deep learning-based detectors, or even customize them with your own data to make real world measurements, and images, using the interactive calibration apps, and object analysis workflow. and to ramp up quickly on deep learning with the help of pre-trained networks, and detailed examples in documentation.

so in conclusion, if you're thinking where to go from here, here are some next steps. go to the computer vision toolbox product page to learn more about computer vision, its applications, and other features, and capabilities that come with the toolbox. if you want a more in-depth experience on learning how to use computer vision toolbox, sign up for an instructor led training course. this is available also as an online course. as mentioned before, there is also one on deep learning. if you're ready to explore the product, and start solving your problems, get a trial license for the product today.

as we have seen, there are some deep learning-based object detectors that are available in the computer vision toolbox. but there is also a lot more that you can do with deep learning. go to the deep learning toolbox page to learn more about this product, and its extensive capabilities. some of you might be also interested in running your computer vision algorithms eventually on a hardware platform like an arm-based raspberry pi, or a gpu-based nvidia jetson board. go to the embedded vision with matlab solution page to learn more about this, and other hardware implementation-related capabilities from matlab. thank you very much for your attention.