At its most basic, findBlobs() can be used to find objects that are lightly colored in an image. If no parameters are specified, the function tries to automatically detect what is bright and what is dark. The following example looks for pennies, as shown in Figure 8-1:

from SimpleCV import Image

pennies = Image("pennies.png")

binPen = pennies.binarize()  

blobs = binPen.findBlobs()  

blobs.show(width=5)  

Figure 8-1. Left: Original image of pennies; Right: Blobs detected

The pennies are now green, as is shown in Figure 8-1. After the blob is found, several other functions provide basic information about the feature, such as its size, location, and orientation, as demonstrated in the next block of code:

from SimpleCV import Image

pennies = Image("pennies.png")

binPen = pennies.binarize()

blobs = binPen.findBlobs()

print "Areas: ", blobs.area()  

print "Angles: ", blobs.angle()  

print "Centers: ", blobs.coordinates()  

These are just a few of the available FeatureSet functions designed to return various attributes of the features. For information about these functions, see the FeatureSet section of this chapter.

The findBlobs() function easily finds lightly colored blobs on a dark background. This is one reason why binarizing an image makes it easier to detect the object of interest. But what if the objects of interest are darkly colored on a light background? In that case, use the invert() function. For instance, the next example demonstrates how to find the chess pieces in Figure 8-2:

Figure 8-2. Black chess pieces

from SimpleCV import Image

img = Image("chessmen.png")

invImg = img.invert() 

blobs = invImg.findBlobs() 

blobs.show(width=2) 

img.addDrawingLayer(invImg.dl()) 

img.show()

The result will look like Figure 8-3.

Figure 8-3. Top: The original image; Center: Blobs drawn on the inverted image; Bottom: Blobs on the original image

The world does not consist solely of light and dark objects. In many cases, the actual color is more important than the brightness or darkness of the objects. The next example shows how to identify the blue candies in Figure 8-4.

Figure 8-4. Everyone knows the blue ones are the tastiest

To find the blobs that represent the blue candies, we use the color information returned from the colorDistance() function that we first introduced in Chapter 4 and later revisited in Chapter 5. Here’s the example code:

from SimpleCV import Color, Image

img = Image("mandms.png")

blue_distance = img.colorDistance(Color.BLUE).invert()  

blobs = blue_distance.findBlobs()  

blobs.draw(color=Color.PUCE, width=3)  

blue_distance.show()

img.addDrawingLayer(blue_distance.dl()) 

img.show()

The resulting matches for the blue candies will look like Figure 8-5.

Figure 8-5. Left: the original image; Center: blobs based on the blue distance; Right: The blobs on the original image

Sometimes the lighting conditions can make color detection more difficult. To demonstrate the problem, Figure 8-6 is based on the original picture of the candies, but the left part of the image is darkened. The hueDistance() function is a better choice for this type of scenario. For instance, if the photo looked like Figure 8-6, where the right half is darkened, then colorDistance() wouldn't work very well on the right half. The right half of the image is intentionally very dark, but the following example shows how the colors can still be used to find blobs and provide a good example of why hue is more valuable than RGB color in cases where lighting may vary.

Figure 8-6. The candies with the right side darkened

To see how this is a problem, first consider using the previous code on this picture:

from SimpleCV import Color, Image

img = Image("mandms-dark.png")

blue_distance = img.colorDistance(Color.BLUE).invert()

blobs = blue_distance.findBlobs()

blobs.draw(color=Color.PUCE, width=3)

img.addDrawingLayer(blue_distance.dl())

img.show()

The results are shown in Figure 8-7. Notice that only the blue candies on the left are detected.

Figure 8-7. Finding blue candies with the dark right side

To resolve this problem use hueDistance() instead of colorDistance(). Because the hue is more robust to changes in light, the darkened right half of the image won’t create a problem.

from SimpleCV import Color, Image

img = Image("mandms-dark.png")

blue_distance = img.hueDistance(Color.BLUE).invert() 

blobs = blue_distance.findBlobs()

blobs.draw(color=Color.PUCE, width=3)

img.addDrawingLayer(blue_distance.dl())

img.show()

Figure 8-8. Blobs detected with hueDistance()

A line feature is a straight edge in an image that usually denotes the boundary of an object. It sounds fairly straightforward, but the calculations involved for identifying lines can be a bit complex. The reason is because an edge is really a list of (x, y) coordinates, and any two coordinates could possibly be connected by a straight line. For instance, Figure 8-9 shows four coordinates and two different examples of line segments that might connect those four points. It’s hard to say which one is right—or if either of them are, since there are also other possible solutions. The way this problem is handled behind-the-scenes is by using the Hough transform technique. This technique effectively looks at all of the possible lines for the points and then figures out which lines show up the most often. The more frequent a line is, the more likely the line is an actual feature.

Figure 8-9. Left: Four coordinates; Center: One possible scenario for lines connecting the points; Right: An alternative scenario

To find the line features in an image, use the findLines() function. The function itself utilizes the Hough transform and returns a FeatureSet of the lines found. The functions available with a FeatureSet are the same regardless of the type of feature involved. However, there are FeatureSet functions that may be useful when dealing with lines. These functions include:

The following code demonstrates how to find and then display the lines in an image. The example looks for lines on a block of wood.

from SimpleCV import Image

img = Image("block.png")

lines = img.findLines()  

lines.draw(width=3)  

img.show()

The lines found on the image are shown in Figure 8-10.

Figure 8-10. Example of basic line detection on a block of wood

Because this is just a simple block of wood in a well-lit environment, the findLines() function does a reasonable job finding the line features using the default values for its parameters. Many situations may require some tweaking to findLines() to get the desired results. For instance, notice that it found the long lines along the top and bottom of the block, but it did not find the lines along the side.

The findLines() function includes five different tuning parameters to help improve the quality of the results:

The threshold parameter for findLines() works in much the same way as the threshold parameter does for the findBlobs() function. If no threshold argument is provided, the default value it uses is set to 80. Lower threshold values result in more lines being found by the function; higher values result in fewer lines being found. Using the block of wood picture again, here’s the code using a low threshold value:

from SimpleCV import Image

img = Image("block.png")

# Set a low threshold
lines = img.findLines(threshold=10)

lines.draw(width=3)

img.show()

Figure 8-11 shows what the resulting image would look like—with many more lines detected on the block. Notice that it found one of the side lines, but at the cost of several superfluous lines along the grains of wood.

Figure 8-11. Line detection at a lower threshold

One way to get rid of small lines is to use the minlinelength parameter to weed out short lines. The length of a line is measured in pixels, and the default value findLines() uses is 30 pixels long. In the example below, the minimum length is boosted, weeding out some lines.

from SimpleCV import Image

img = Image("block.png")

lines = img.findLines(threshold=10, minlinelength=50)

lines.draw(width=3)

img.show()

The result is shown in Figure 8-12. Notice that it eliminated a couple of the extra lines, but it came at a cost of eliminating the the side lines again.

Figure 8-12. Line detection with an increased minimum length

Changing the line length doesn’t solve the problem. The two ends of the image still are not found. In fact, it could create the opposite problem. Sometimes the algorithm may find very small lines and it needs to know whether those small line segments actually represent one larger continuous line. The findLines() function can ignore small gaps in a line, and recognize it as the larger overall line. By default, the function combines two segments of a line if the gap between them is 10 pixels or less. Use the maxlinegap parameter to fine tune how this works. The following example allows for a larger gap between lines, potentially allowing it to discover a few small lines that constitute the edge.

from SimpleCV import Image

img = Image("block.png")

lines = img.findLines(threshold=10, maxlinegap=20)

lines.draw(width=3)

img.show()

The result restores the right edge line again, but once again, it finds a lot of superfluous lines, as demonstrated in Figure 8-13.

Figure 8-13. Line detection with a larger allowance for the gap

While setting the minimum line length decreased the number of lines found in the painting, adding in a longer gap then dramatically increased the number of lines. With the bigger gap, the line segments can be combined to meet the line length requirements and more lines are then recognized. The last two parameters, cannyth1 and cannyth2, are thresholds for the Canny edge detector. Roughly speaking, edges are detected by looking for changes in brightness. The first of these threshold parameters controls how much the brightness needs to change to detect an edge. The second parameter controls the threshold for linking together multiple edges. Both of these parameters act the same way as the previous three parameters: smaller values mean more lines will be detected, which could just be adding noise. Conversely, larger values will have less lines detected, but may mean that some valid lines aren’t being returned. With all of these parameters, the trick is to work with the parameters until they are in the range that makes the most sense for the application.

Of course, sometimes it is easier to simply modify the image to reduce the noise rather than fine-tuning the parameters. The following example finds the desired lines on the block:

from SimpleCV import Image

img = Image('block.png')

dist = img.colorDistance((150, 90, 50))

bin = dist.binarize(70).morphClose()

lines = bin.findLines(threshold=10, minlinelength=15)

lines.draw(width=3)

# Move the lines drawn on the binary image back to the main image
img.addDrawingLayer(bin.dl())

img.show()

By binarizing the image, it eliminated a bunch of the noise that was causing the false-positive lines to appear where they should not. As a result, this draws lines around the block, as shown in Figure 8-14.

Figure 8-14. Block with lines on all of the edges

Circles are the next major feature that the SimpleCV framework can extract. The method to find circular features is called findCircle(), and it works the same way findLines() does. It returns a FeatureSet of the circular features it finds, and it also has parameters to help set its sensitivity. These parameters include:

As with lines, there are FeatureSet functions that are more appropriate when dealing with circles, too. These functions include:

To showcase how to use the findCircle() function, we’ll take a look at an image of coffee mugs where one coffee mug also happens to have a ping-pong ball in it. Because there isn’t any beer in the mugs, we’ll assume that someone is very good at the game of beer pong—or perhaps is practicing for a later game? Either way, here’s the example code:

from SimpleCV import Image

img = Image("pong.png")

circles = img.findCircle(canny=200,thresh=250,distance=15)  

circles = circles.sortArea()  

circles.draw(width=4)  

circles[0].draw(color=Color.RED, width=4)  

img_with_circles = img.applyLayers()  

edges_in_image = img.edges(t2=200)  

final = img.sideBySide(edges_in_image.sideBySide(img_with_circles)).scale(0.5)  

final.show()

Figure 8-15. Image showing the detected circles

The next example combines finding both circle and line features by reading the line on a dial. These types of dials can be found in a variety of places, from large equipment to lighting controls around the house. For our example, we’ll use the dial in Figure 8-16 with four different settings. The code first searches for the dial in the images, and then searches for the line on each dial. Then it measures the angle of that line, and prints it on the image of the dial.

Figure 8-16. An analog dial like those found in older thermostats

from SimpleCV import Image

# Load the images of four dials with different settings
img0 = Image("dial1.png")
img1 = Image("dial2.png")
img2 = Image("dial3.png")
img3 = Image("dial4.png")

# Store them in an array of images
images = (img0,img1,img2,img3)

# This stores the dial-only part of the images
dials = []

for img in images:
     circles = img.findCircle().sortArea()  
     dial = circles[-1].crop()  

     lines = dial.findLines(threshold=40,cannyth1=270,cannyth2=400)  
     lines = lines.sortLength()  
     lines[-1].draw(color=Color.RED)

     lineAngle = lines[-1].angle()  

     if (lines[-1].x < (dial.width / 2)):  
          if (lines[-1].y < (dial.width / 2)):
                lineAngle = lineAngle - 180
          else:
               lineAngle = 180 + lineAngle

     dial.drawText(str(lineAngle),10,10)
     dial = dial.applyLayers()
     dials.append(dial)

result = dials[0].sideBySide(dials[1].sideBySide(dials[2].sideBySide(dials[3])))  
result.show()

Figure 8-17. The results of the analog dial reader