Once we have the NumPy array of floating-point coordinates for the detected corners, we convert them from floats to ints so they can serve as pixel positions. The `ravel()` method flattens each corner array (for example `[[0,1],[2,3]]` becomes `[0,1,2,3]`), letting us unpack the x and y values directly. ```python corners = np.int0(corners) for corner in corners: x, y = corner.ravel() cv2.circle(img, (x, y), 5, (255, 0, 0), -1) ``` Note that if the image is still grayscale, a colored (BGR) drawing parameter will not display correctly. To make the corners more obvious, we can also draw lines connecting every pair of corners: ```python for i in range(len(corners)): for j in range(i + 1, len(corners)): corner1 = tuple(corners[i][0]) corner2 = tuple(corners[j][0]) cv2.line(img, corner1, corner2, (255, 0, 0), 1) ``` The `[0]` indexing is only needed when the corner array has not been flattened.

Drawing Detected Corners in OpenCV

Use OpenCV's Shi-Tomasi Good Features to Track corner detector on a grayscale image:

```python
img = cv2.imread('path')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
corners = cv2.goodFeaturesToTrack(gray, N, Q, ME)
```

`N` limits the result to the best N corner candidates. `Q` is a quality cutoff from 0 to 1; increasing it retains only stronger candidates. `ME` is the minimum Euclidean distance allowed between returned corners, reducing near-duplicate detections. The result contains floating-point corner coordinates that can be converted to pixel positions for drawing.

University of Michigan - Ann Arbor

Google

Advanced Concepts:
- Object Recognition
- Object Labeling
- Contour Maps
- Machine Learning Applications
- Color Detection
- Corner Detection
- Randomized Color Generation
- Color Extraction

Advanced Concepts

To extract a color from an image we need to convert the BGR file into a HSV file. 
```python
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
```
Once we have converted the file into an HSV format, we need to pick the lower bound and upper bound values to determine the color we are extracting. However, we would need to find the associated HSV values. We can search it up online with a color picker , we can take a pixel from the original image or pass it BGR values and convert that into HSV values using the same method as above. 

```python
BGR_color = np.array([[[255,0,0]]])
print(cv2.cvtColor(BGR_color, cv2.COLOR_BGR2HSV)
```

For example if we wanted to extract blue we would use the following code:
```python
lower_blue = np.array([90, 50, 50])
upper_blue = np.array([130, 255, 255])

mask = cv2.inRange(hsv, lower_blue, upper_blue)

result = cv2.bitwise_and(frame, frame, mask = mask)

cv2.imshow('frame', result)
```

Mask will return a layer that only has blue pixels within the range. Otherwise everything else is going to be blacked out. The mask should be fine tuned to more perform a better job at preventing other colors from appearing. 


Color Extraction 

OpenCV has pre-trained classifiers that will be able to look through the image and search for features common to eyes and faces. 

```python
cap = cv2.VideoCapture(0)
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'hararcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'hararcascade_eye.xml')

while  True:
     ret, frame = cap.read()
     
     #convert to gray scale, cascades require gray scale
     cv2.cvtColor(frame, cv2.COLOR_BGR_2_GRAY)

     faces = face_cascade.detectMultiScale(gray, 1.3, 5)
     for (x, y, w, h) in faces:
          cv2.rectangle(frame, (x,y), (x+w, y+h), (255, 0, 0), 5)
          roi_gray = gray[y:y+w, x:x+w]
          roi_color = frame[y:y+h, x:x+w]
          
          eyes = eye_cascade.detectMultiScale(roi_gray, 1.3, 5)
          for (ex, ey, ew, eh) in eyes:
               cv2.rectangle(roi_color, (ex, ey), (ex+ew, ey+eh), (0, 255, 0), 5)

     cv2.imshow('frame', frame)

     if cv2.waitKey(1) == ord('q'):
          break

cap.release()
cv2.destroyAllWindows()
```
Since the cascades were trained on certain sized images, i.e. 400x400 and may not be able to work on an image file that is 10000x10000. Changing the scale factor will allow for a speed/accuracy trade off. Closer to 1 values will slow down but more accurate. 

minNeighbors is an accuracy specification. How many different features must we detect before we can label it as a face / eye. 

minSize and maxSize are just optional parameters for if you know how big faces are in the images. 
detectMultiScale(base image, scale factor, minNeighbors, minSize, maxSize)

Face and Eye Detection

Contour maps are a tool that can be used to reduce an image to a set of lines where we can use pattern recognition to identify common features. This is used when identifying specific features in people's eyes or on a persons face. 
```
```
Contours are the curves that join all the continuous points on the image. We usually use binary image when working with contours. To turn something to binary, we just use the ```cvtColor``` method and convert it to grayscale. 

This is very useful for shape analysis as well. You can download the openCV logo and try the following code example out on that image. It will outline the edges of all 9 shapes. 

Contour Maps

Basic template matching involves having an identical object image (template) and searching for that same pattern within a larger base image. OpenCV provides several methods for template matching:

```python
methods = [cv2.TM_CCOEFF, cv2.TM_CCOEFF_NORMED, cv2.TM_CCORR, cv2.TM_CCORR_NORMED, cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]
```

OpenCV recommends trying all the methods and choosing whichever gives the best match for your use case.

```python
img = cv2.imread('path', 0)
template = cv2.imread('path', 0)
height, width = template.shape

for method in methods:
    img2 = img.copy()
    result = cv2.matchTemplate(img2, template, method)
    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
    if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
        location = min_loc
    else:
        location = max_loc
    bottom_right = (location[0] + width, location[1] + height)
    cv2.rectangle(img2, location, bottom_right, 255, 5)
    cv2.imshow("Match", img2)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
```

This slides the template across the base image and scores how well it matches at each position, returning an array of size (W_base - W_temp + 1, H_base - H_temp + 1). The best-matching location is used to draw a rectangle on the base image: SQDIFF-based methods use `min_loc`, while all other methods use `max_loc`.

Learn Before

Related

Learn After