Applying Threshold on a Colored Mat

Back to the basics . Do you remember how to threshold on a mat, and keep only the values in the matrix above 150?

Yes, you’re correct: use the threshold function.

The input matrix contains various values, some below and some above the threshold value of 150. When applying threshold, the values below are set to 0 and the ones above are set to threshold’s second parameter value, 255.

This results in the following matrix (Figure 3-1):

That was for a one-channel mat , but what happens if we do the same on a three-channel mat?

Converting the colors to BGR duplicates each of the values of the one-channel mat to the same three values on the same pixel.

Applying the OpenCV threshold function right afterward applies the threshold to all the values over each channel. And so the resulting mat loses the 100 values of the original mat and keeps only the 255 values.

A 3×3 matrix is a bit too small to show onscreen, so let’s use resize on the input matrix first.

(-> (u/matrix-to-mat [[0 0 170]

                      [0 0 170]

                      [100 100 0]])

    (cvt-color! COLOR_GRAY2BGR)

    (resize! (new-size 50 50) 1 1 INTER_AREA)

    (u/mat-view))

Applying a similar threshold on the preceding mat keeps the light gray, which has a value above the threshold, but removes the darker gray by turning it to black.

This gives us Figure 3-2.

Notice the use of a specific interpolation parameter with resize, INTER_AREA, which nicely cuts the shape sharp, instead of interpolating and forcing a blur.

Just for some extra info, the default resize method gives something like Figure 3-3, which can be used in other circumstances , but this is not what we want here.

Anyway, back to the exercise, and you probably have it at this point: applying a standard threshold pushes forward vivid colors.

Let’s see how that works on a mat loaded from an image, and let’s load our first image of the chapter (Figure 3-4).

(def rose

  (imread "resources/chapter03/rose.jpg" IMREAD_REDUCED_COLOR_4))

We start by applying the same threshold that was applied on the mat loaded from a matrix, but this time on the rose image .

You get a striking result! (Figure 3-5)

In a nicely shot photograph, this actually gives you an artistic feeling that you can build upon for cards and Christmas presents!

Let’s now apply a similar technique on a completely different image. We’ll turn the picture to black and white first and see what the result is.

This time, the picture is of playful kittens, as shown in Figure 3-6.

 (-> "resources/chapter03/ai6.jpg"

    (imread IMREAD_REDUCED_COLOR_2)

    (u/mat-view))

If you apply a similar threshold but on the grayscale version , something rather interesting happens.

The two cats are actually standing out and being highlighted (Figure 3-7).

Cool; this means that the shape we wanted to stand out has been highlighted.

Something similar to this can be used to find out shapes and moving objects; more in recipe 3-6 and 3-7.

For now, and to keep things artistic, let’s work on a small function that will turn all the colors under a given threshold to one color, and all the values above the threshold to another one.

In coding happiness, we will create a low-high! function that does the algorithm described in the preceding.

The low-high! function is composed of cvt-color!, threshold, and set-to, all functions you already have seen.

We will call it on the rose picture, with a threshold of 150 and a white smoke to light blue split.

Executing the preceding snippet gives us Figure 3-8.

Great. But, you ask, do we really need to create two masks for this? Indeed, you do not. You can do a bitwise operation perfectly on the first mask. To do this, simply comment out the second mask creation and use bitwise-not! before calling set-to the second time.

From there, you could also apply thresholds on different color maps, or create ranges to use as threshold values.

Another idea here is, obviously, to just hot-space-queen-ize any picture.

In case you are wondering, the following snippet does that for you.

This really just is calling low-high! four times, each time with colors from the Queen album Hot Space, from 1982.

And the old-fashioned result is shown in Figure 3-9.

You really know how to set the mood

And you really get inside the groove

Cool cat

Queen – “Cool Cat”

Channels by Hand

Whenever you are about to play with channels of a mat, remember the opencv split function. The function separates the channels in a list of independent mats, so you can entirely focus on only one of them.

You can then apply transformations to that specific mat, without touching the others, and when finished, you can return to a multichannel mat using the merge function, which does the reverse and takes a list of mats , one per channel, and creates a target mat combining all the channels into one mat.

To see that in action, suppose you have a simple orange mat (Figure 3-10).

(def orange-mat

  (new-mat 3 3 CV_8UC3 rgb/orange-2))

If you want to turn the orange mat into a red one, you would simply set all the values of the green channel to 0.

So, you start by splitting the RGB channels into three mats; then, set all the values of the second mat to 0 and merge all three mats into one.

First, let’s split the mat into channels, and see the content of each of them.

In happy coding, this gives

The three channels are now separated into three elements in the list. You can look at the content of each channel simply by using dump.

For example, dump of the blue channel:

or dump of the green channel :

Finally, dump of the red channel:

From there, let’s turn all those 154 values in the green channel to 0.

And then, let’s merge all the different mats back to a single mat and get Figure 3-11.

(merge channels red-mat)

The green intensity on all pixels in the mat was uniformly set to 0, and so with all the blue channel values already set to 0, the resulting mat is a completely red one.

We can combine all the different steps of this small exercise and create the function update-channel!, which takes a mat, a function, and the channel to apply the function to and then returns the resulting mat.

Let’s try a first version using u/mat-to-bytes and u/bytes-to-mat! to convert back and forth between mat and byte arrays.

This gets complicated, but is actually the easiest version I could come up with to explain the flow of the transformation .

This should now, at least, read almost sequentially as in the following:

Now let’s get back to my sister’s cat, who’s been sleeping on the couch for some time. Time to tease him a bit and wake him up.

With the help of the update-channel! function, let’s turn all the blue and green channel values to their maximum possible values of 255. We could have written a function that applies multiple functions at the same time, but for now let’s just call the same function one by one in a row.

This is not very useful as far as imaging goes, nor very useful for my sister’s cat either, but by maxing out all the values of the blue and green channels, we get a picture that is all cyan (Figure 3-12).

This newly created function can also be combined with converting colorspace.

Thus, switching to HSV color space before calling update-channel! gives you full control over the mat’s color.

The preceding code applies a blue filter, leaving saturation and brightness untouched, thus still keeping the image dynamics .

Of course, you could try with a pink filter, setting the filter’s value to 150, or red, by setting the filter’s value to 120, or any other possible value. Try it out!

For now, enjoy the blue variation in Figure 3-13.

Personally, I also like the YUV switch combined with maximizing all the luminance values (Y).

This gives a kind of watercolor feel to the image (Figure 3-14).

Transform

If you remember transform , you could also apply different sorts of transformation using the opencv transform function.

To understand the background of transform a bit, let’s get back once again to the usual byte-per-byte matrix manipulation, first on a one-channel 3×3 mat that we would like to make slightly darker.

This can be viewed with the following code (Figure 3-15).

(u/mat-view (-> s-mat clone (resize! (new-size 30 30) 1 1 INTER_AREA)))

Then we define a 1×1 transformation matrix, with one value of 0.7.

Next, we apply the transformation in place and also dump the result to see the values out from the transformation.

Calling the transform function has the effect of turning all the values of the input matrix to their original value multiplied by 0.7.

The result is shown in the following matrix:

It also means that the visuals of the mat have become darker (Figure 3-16):

(u/mat-view (-> s-mat (resize! (new-size 30 30) 1 1 INTER_AREA)))

Those transformations work much the same for mats with multiple channels. So, let’s grab an example and move to a colored colorspace (yeah, I know) using cvt-color!

Because the mat is now made of three channels, we now need a 3×3 transformation matrix.

The following transformation mat will give more strength to the blue channel.

Applying the transformation to the newly colored mat gives you Figure 3-17, where blue is prominently standing out.

Since there is definitely no way we can leave my sister’s cat in peace, let’s apply a similar transformation to it.

The code is exactly the same as the preceding small mat example, but applied on an image .

And Figure 3-18 shows a blue version of a usually white cat.

If you wanted blue in the input to also influence red in the output, you could use a matrix slightly similar to the following:

You can understand why by now, right? [2 0 1.1] means that the blue in the input is gaining intensity, but that it also contributes to the intensity of red in the output.

You should probably try a few transformation matrices by yourself to get a feel for them.

So, now, how could you increase the luminosity of a mat using a similar technique?

Yes, that’s right: by converting the matrix to HSV colorspace first, then multiplying the third channel and keeping the others as they are.

The following sample increases the luminosity by 1.5 in the same fashion .

Figure 3-19 shows the image output of the preceding snippet.

Artful Transformations

To conclude this recipe, let’s play a bit with luminosity and contours to create something a bit artistic.

We want to create a watercolor version of the input picture, by maximizing the luminosity. We also want to create a “contour” version of the image, by using opencv’s canny quick feature of contour detection. Then finally, we will combine the two mats for a pencil-over-watercolor effect.

First, let’s work on the background. The background is created by performing two transformations in a row: one to max out the luminosity in the YUV color space, the other to get it more vivid by increasing blue and red colors.

If you get a result that is too transparent, you could also add another transformation at the end of the pipeline to increase contrast ; this is easily done in another colorspace, HSV.

This gives us a nice pink-y background (Figure 3-20).

Next is the foreground. The front cat is created using a call to opencv’s canny function. This time, this is done in the one-channel gray color space.

The canny version of my sister’s cat gives the following (Figure 3-21):

Then, the two mats are combined using a simple call to the function bitwise-and, which merges two mats together by doing simple “and” bit operations.

This gives the nice artful cat in Figure 3-22.

While the pink color may not be your favorite, you now have all the tools to modify to your liking the flows presented in this recipe to create many variations of artful cats, with different background colors and also different foregrounds.

But please. No dogs.

Bilateral Cartoon

The bilateral filter is actually doing a lot of the cartoon work, so let’s see if we can skip the canny processing and stick with just using the bilateral filter step.

A possible implementation is shown in the following:

The output of cartoon-0! applied to Johan makes it to Figure 3-30.

(-> "resources/chapter03/johan.jpg"

(imread IMREAD_REDUCED_COLOR_8)

cartoon-0!

u/mat-view)

Here again, the parameters of the bilateral filter pretty much make all the work.

Changing (bilateral-filter! 10 250 30) to (bilateral-filter! 9 9 7) gives a completely different feeling.

And Johan now looks even more artistic and thoughtful (Figure 3-31).

Grayed with Update Channel

The last technique of this recipe will take us back to use the update-channel! function written in the previous recipe.

This gives the following slightly long but simple pipeline:

This is nothing you would not understand by now, but the pipeline is quite a pleasure to write and its result even more so, because it gives more depth to the output than the other techniques used up to now (Figure 3-32).

The output of the pipeline looks great, but the pixels have had quite a bit of processing, so it is hard to tell what’s inside each of them at this stage, and postprocessing after that needs a bit of care.

Say you want to increase the luminosity or change the color of the preceding output; it is usually better to switch again to HSV color space and increase the luminosity before changing anything on the colors, as highlighted in the following:

The final processing pipeline gives us a shining blue Johan (Figure 3-33). The overall color is blue due to channel 0’s value set to 5 in HSV range, and the luminosity set to 250, almost the maximum value.

As a bonus, we also just flipped the image horizontally to end this recipe on a forward-looking picture!

Background

pyr-down! is probably new to you. This decreases the resolution of an image . Let’s compare the mats before and after applying the change of resolution done by the following snippet.

Before:

After:

Basically, the resolution of the mat has been divided by 2, rounded to the pixel. (Yes, I have heard stories of 1/2 pixels before, but beware… those are not true!!)

Using a factor of 4, and thus applying the resolution downgrade four times, we get a mat that is now 27×27 and looks like the mat in Figure 3-35.

To create the background effect, we actually need a mat of the same size as the original, so there is a need to resize the output to the size of the original.

The first idea is of course to simply try the usual resize! function:

But that does result in something not very satisfying to the eyes. Figure 3-36 indeed shows some quite visible weird pixelization of the resized mat.

Let’s try something else. There is a reverse function of pyr-down, named pyr-up, which doubles the resolution of a mat. To use it effectively, we can apply pyr-up in a loop , and loop the same number of times as done with pyr-down.

The resulting mat is similar to Figure 3-36, but is much smoother, as shown in Figure 3-37.

The background is finalized by applying blur in the mat in between the pyr-down and pyr-up dance.

So:

The output is kept for later, and that’s it for the background ; let’s move to the edge-finding part for the foreground.

Foreground and Result

The foreground is going to be mostly a copy-paste exercise of the previous recipe. You can of course create your own variation at this stage; we will use here a cartooning function made of a median-blur and an adaptive-threshold step.

Using the old town image as input, this time you get a mat showing only the prominent edges, as shown in Figure 3-38.

To finish the exercise, we now combine the two mats using bitwise-and. Basically, since the edges are black, a bitwise-and operation keeps them black, and their values will be copied over as they are to the output mat.

This will have the consequence of copying the edges over unchanged onto the target result, and since the remaining part of the edges mat is made of white, bitwise-and will be the value of the other mat, and so the color of the background mat will take precedence.

This gives you the sketching effect of Figure 3-39.

With the adaptive threshold step, you can tune the way the front sketching looks.

We used 9 as edges-thickness and 7 as edges-number in the first sketch; let’s see what happens if we put those two parameters to 5.

This gives more space to the color of the background, by reducing the thickness of the edges (Figure 3-40).

It’s now up to you to play and improvise from there!

Summary

The sketch! function is made of smoothing! and edges!. First, let’s use smoothing! to create the background.

Then edges! to create the foreground.

Finally, we can use sketch!, the combination of background and foreground.

Calling sketch! is relatively easy. You can try the following snippet:

And instantly turn the landscape picture of Figure 3-41 …

into the sketched version of Figure 3-42.

A few others have been put in the samples, but now is indeed the time to take your own pictures and give those functions and parameters a shot.

Apply the Canvas

Now that the main picture has been turned to a crayon-styled art form, it would be nice to lay this out on a canvas-looking mat. As presented, this is done using the multiply function from OpenCV.

We want the canvas to look like a very old parchment, and we will use the one from Figure 3-46.

Now we will create the apply-canvas! function, which takes the front-end sketch, and the canvas, and applies the multiply function between them. (/ 1 256.0) is the value used for the multiplication; since these are gray bytes here, the bigger the value the whiter, and so here (/ 1 256.0) makes the dark lines stand out quite nicely on the final result.

Whoo-hoo. Almost there; now let’s call this newly created function

And enjoy the drawing on the canvas (Figure 3-47).

Now is obviously the time for you to go and find/scan your own old papers, to try a few things using this technique ; or why not reuse the cartoon functions from previous recipes to lay on top of the different papers?

Find Lines of a Tennis Court with Hough-Lines

The first part of this tutorial shows how to find lines within an image. We will take the example of a tennis court .

You have probably seen a tennis court before, and this one is not so different from the others (Figure 3-48). If you have never seen a tennis court before, this is a great introduction all the same, but you should probably stop reading and go play a game already.

Preparing the target for the hough-lines function is done by converting the original tennis court picture to gray, then applying a simple canny transformation.

With the expected result of the lines standing out on a black background, as shown in Figure 3-49.

Lines are collected in a mat in the underlying Java version of opencv, and so, no way to avoid this, we will also prepare a mat to receive the resulting lines .

The hough-lines function itself is called with a bunch of parameters. The full underlying polar system explanation for the hough transformation can be found on the OpenCV web site:

https://docs.opencv.org/3.3.1/d9/db0/tutorial_hough_lines.html

You don’t really need to read everything just now, but it’s good to realize what can be done and what cannot.

For now, we will just apply the same parameters suggested in the linked tutorial.

The resulting mat of lines is made of a list of rows with two values, rho and theta, on each row.

Creating the two points required to draw a line from rho and theta is a bit complicated but is described in the opencv tutorial .

For now, the following function does the work for you.

Drawing the found lines on top of the tennis court mat creates the image in Figure 3-50.

Note that when calling hough-lines, changing the parameter with value 1 to a value of 2 gives you way more lines, but you may need to filter the lines yourself afterward.

Also by experience , changing the Math/PI rounding from 180 to 90 gives fewer lines but better results.

Hough-Lines-P

Another variant of the hough-lines function, named hough-lines-p , is an enhanced version with probabilistic mathematics added, and it usually gives a better set of lines by performing guesses.

To try hough-lines with P, we will this time take the example of… a soccer field.

As per the original hough-lines example, we turn the soccer field to gray and apply a slight gaussian blur to remove possible imperfections in the source image.

The resulting grayed version of the soccer field is shown in Figure 3-51.

Let’s now make a canny version of the court to create the edges.

Now, we call hough-lines-p. The parameters used are explained in line in the following code snippet. Lines are expected to be collected from the newly created edges mat .

The parameters are ready; let’s call hough-lines-p, with the result being stored in the lines mat.

This time, the lines are slightly easier to draw than with the regular hough-lines function. Each line of the result mat is made of four values, for the two points needed to draw the line.

The result of drawing the results of hough-lines-p is displayed in Figure 3-52.

Finding Pockets on a Pool Table

No more running around on a court; let’s move to… the billiard table!

In a similar way, opencv has a function named hough-circles to look for circle-looking shapes. What’s more, the function is pretty easy to put in action.

Let’s get the pool table ready first.

With hough-circles, it seems you can actually get better results by bypassing the canny step in the preprocessing .

The following snippet now shows where to put values for the min and max radius of the circles to look for in the source mat.

Here again, circles are collected in a mat, with each line containing the x and y position of the center of the circle and its radius.

Finally, we simply draw circles on the result mat with the opencv circle function.

All the pockets are now highlighted in white in Figure 3-53.

Note that if you put the minRadius value too low, you quickly get false positives with the regular balls, as shown in Figure 3-54.

So defining precisely what is searched for is the recipe for success in most of your OpenCV endeavors (and maybe other ones too…).

And so, to avoid false positives here, it is also probably a good idea to filter on colors before accepting and drawing the lines. Let’s see how to do this next.

Finding Circles

In this short example, we will be looking for red circles in a mat where circles of multiple colors can be found.

The bgr-image is shown in Figure 3-55.

You may not see it if you are reading straight from the black-and-white version of the book, but we will be focusing on the large bottom left circle, which is of a vivid red.

If you remember lessons from the previous recipes, you already know we need to change the color space to HSV and then filter on a hue range between 0 and 10.

The following snippet shows how to do this along with some extra blurring to ease processing later on.

All the circles we are not looking for have disappeared from the mat resulting from the small pipeline, and the only circle we are looking for is now standing out nicely (Figure 3-56).

Now we can apply the same hough-circles call as was seen just previously; again, the circle will be collected in the circle mat, which will be a 1×1 mat with three channels .

The result of drawing the circle with a border is shown in Figure 3-57. The red circle has been highlighted with a green-yellow color and a thickness of 5.

Using Draw Segment

Sometimes, the easiest may be to simply use a technique using the provided segment detector. It is less origami friendly, since the methods used are straight Java method calls (so prefixed with a dot “.”), but the snippet is rather self-contained.

Let’s try that on the previously seen soccer field. We’ll load it straight to gray this time and see how the segment detector behaves.

We call detect on the line-segment-detector, using Clojure Java Interop for now.

At this stage, the lines mat metadata is 161*1*CV_32FC4, meaning 161 rows, each made of 1 column and 4 channels per dot, meaning 2 points per value.

The detector has a helpful drawSegments function, which we can call to get the resulting mat .

The soccer field mat is now showing in Figure 3-58, this time with all the lines highlighted, including circles and semicircles.

Sony Headphones

They are not so new anymore, but I love my Sony headphones . I simply bring them everywhere, and you can feed your narcissism and get all the attention you need by simply wearing them. They also get you the best sound, whether on the train or on the plane…

Let’s have a quick game of finding my headphones’ contours.

My headphones still have a cable, because I like the sound better still, whatever some big companies are saying.

Anyway, the headphones are shown in Figure 3-59.

First, we need to prepare the headset to be easier to analyze. To do this, we create a mask of the interesting part, the headphones themselves.

The inverted thresh binary output is shown in Figure 3-60.

Then with the use of the mask, we create a masked-input mat that will be used to ease the finding contours step.

Have you noticed? Yes, there was an easier way to create the input, by simply creating a noninverted mask in the first place, but this second method gives more control for preparing the input mat.

So here we basically proceed in two steps. First, set all the pixels of the original mat to black when the same pixel value of the mask is 1. Next, set all the other values to white, on the opposite version of the mask .

The prepared result mat is in Figure 3-61.

Now that the mat that will be used to find contours is ready, you can almost directly call find-contours on it.

find-contours takes a few obvious parameters, and two ones, the last two, that are a bit more obscure.

RETR_LIST is the simplest one, and returns all the contours as a list, while RETR_TREE is the most often used, and means that the contours are hierarchically ordered.

CHAIN_APPROX_NONE means all the points of the found contours are stored. Usually though, when drawing those contours, you do not need all of the points defining them. In case you do not need all of the points, you can use CHAIN_APPROX_SIMPLE, which reduces the number of points defining the contours.

It eventually depends how you handle the contours afterward. But for now, let’s keep all the points!

Alright, now let’s draw rectangles to highlight each found contour. We loop on the contour list, and for each contour we use the bounding-rect function to get a rectangle that wraps the contour itself.

The rectangle retrieve from the bounding-rect call can be used almost as is, and we will draw our first contours with it.

Contours are now showing in Figure 3-62.

Right. Not bad. It is pretty obvious from the picture that the big rectangle spreading over the whole picture is not very useful. That’s why we need a bit of filtering.

That filtering is now done in the following snippet.

And so, drawing only the interesting-contours this time gives something quite accurate.

Figure 3-63 this time shows only useful contours.

Drawing circles instead of rectangles should not be too hard, so here we go with the same loop on interesting-contours , but this time, drawing a circle based on the bounding-rect.

The resulting mat, exercise-2, is shown in Figure 3-64.

Finally, while it’s harder to use for detection processing, you can also use the opencv function draw-contours to nicely draw the free shape of the contour.

We will still be looping on the interesting-contours list. Note that the parameters may feel a bit strange, since draw-contours uses an index along with the list instead of the contour itself, so be careful when using draw-contours.

And finally, the resulting mat can be found in Figure 3-65.

Things are not always so easy, so let’s take another example up in the sky!

Up in the Sky

This second example takes hot-air balloons in the sky, and wants to draw contours on them.

The picture of hot-air balloons in Figure 3-66 seems very innocent and peaceful.

Unfortunately, using the same technique as previously shown to prepare the picture does not reach a very sexy result .

It’s pretty pitch-black in Figure 3-67.

So, let’s try another technique. What would you do to get a better mask?

Yes—why not? Let’s filter all this blue and create a blurred mask from it. This should give you the following snippet.

Nice! Figure 3-68 shows that this actually worked out pretty neatly.

We will now use the complement version of the mask to find the contours.

Using the finding-contours function has no more secrets to hide from you. Or maybe it does? What’s the new-point doing in the parameter list? Don’t worry; it is just an offset value, and here we specify no offset, so 0 0.

Contours are in! Let’s filter on the size and draw circles around them. This is simply a rehash of the previous example.

Nice. You are getting pretty good at those things. Look at and enjoy the result of Figure 3-69.

Next, let’s filter ahead of the drawing, and let’s use the bounding-rect again to draw rectangles.

And yes indeed, if you checked its content, my-contours has only three elements.

Now drawing those rectangles results in Figure 3-70.

Highlight Contours

We will use a picture with many shapes for the first part of this exercise, like the one in Figure 3-71.

The goal here is to draw the contours of each shape with different colors depending on the number of sides of each shape.

The shapes mat is loaded simply with the following snippet:

As was done in the previous recipe, we first prepare a thresh mat from the input by converting a clone of the input to gray, then applying a simple threshold to highlight the shapes.

Looking closely, we can see that the shapes are nicely highlighted, and if you look at Figure 3-72, the thresh is indeed nicely showing the shapes.

Ok, the thresh is ready, so you can now call find-contours on it.

To draw the contours , we first write a dump function that loops on the contours list and draws each one in magenta.

The function works as expected, and the result is shown in Figure 3-73.

But, as we have said, we would like to use a different color for each contour, so let’s write a function that selects a color depending on the sides of the contour.

Unfortunately, even with CHAIN_APPROX_SIMPLE passed as parameter to find-contours, the number of points for each shape is way too high to make any sense.

So, let’s work on reducing the number of points by converting the shapes to approximations.

Two functions are used from opencv, arc-length, and approx-poly-dp. The factor 0.02 is the default proposed by opencv; we will see its impact with different values slightly later in this recipe.

Using this new approx function, we can now count the number of sides by counting the number of points of the approximation.

The following is the how-many-sides function that simply does that.

Everything is in place; let’s rewrite the dumb draw-contours! function into something slightly more evolved using which-color .

And now calling the updated function properly highlights the polygons, counting the number of sides on an approximation of each of the found shapes (Figure 3-74).

Note how the circle still goes slightly overboard, with too many sides , but that was to be expected.

Hand-Drawn Shapes

But perhaps you were going to say that the shapes were nicely showing already, so you still have some doubts about whether the approximation is really useful or not. So, let’s head to a beautiful piece of hand-drawn art that was prepared just for the purpose of this example.

Figure 3-75 shows the newly loaded shapes.

First, let’s call find-contours and draw the shapes defined by them.

Reusing the same draw-contours! function and drawing over the art itself gives Figure 3-76.

Now this time, let’s try something different and use the function fill-convex-poly from the core opencv package.

It’s not very different from draw-contours, and we indeed just loop on the list and use fill-convex-poly on each of the contours .

And so, we get the four shapes turned to blue (Figure 3-77).

As we can see, the contours and shapes are found and can be drawn.

Another way to draw the contours is to use the function polylines. Luckily, the function polylines hides the loop over each element of the contours, and you can just pass in as parameters the contour list as is.

And this time, we nicely get the wireframe only of the contours (Figure 3-78).

Alright, but again those shapes for now all have too many points.

Let’s again use the approx function that was created, and enhance it so we can specify the factor used by approx-poly-dp.

A higher factor means we force the reduction of points to a greater extent. And so, to that effect, let’s increase the usual value of 0.02 to 0.03.

The shapes have been greatly simplified, and the number of sides has quite diminished: the shapes are now easier to identify (Figure 3-79).