```python
import numpy as np
import cv2

img = cv2.imread('opencv-logo.png')
imgray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

ret, thresh = cv2.threshold(imgray, 127, 255, 0)
contours, hierarchy = cv2.findCountours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)

print("Number of Contours = " + str(len(contours))

cv2.drawContours(img, contours, -1, (0, 255, 0) , 3)

cv2.imshow('Image', img)
cv2.imshow('Image gray', imgray)
cv2.waitkey(0)
cv2.destroyAllWindows()
```

Code Example:

Thresholds help OpenCV gauge what is important and what can be ignored. There are many different methods to creating thresholds and each have varying benefits and downsides. So it is important to experiment with them before usage.

Creating Thresholds

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. 

University of Michigan - Ann Arbor

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 uses the Shi-Tomasi Good Features to Track and Corner detection algorithm. We are going to want to convert the images into a gray scale object first. This is because the algorithms work significantly better on grey scale images.

```python
img = cv2.imread(`path`)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
corners = cv2.goodFeaturesToTrack(img, N, Q, ME)
```
The N parameter will return the N best guesses of corners. The Q parameter is a cut off on how specific the corner will be. The parameter ranges from 0 to 1 and the closer to 1 the more confident the corner will have to be to be included in the final output. The ME parameter is the minimum Euclidean distance between two corners, this is to prevent it from returning two corners when they are actually the same corner.

The output will be a list of floating point values. 

Corner Detection

Basic Template matching involves having an identical object file and then searching for the same pattern to appear in the base image. 
There are many methods to do template matching

```python
methods = [cv2.TM_CCOEFF, cv2.TMCCOEFF_NORMED, cv2.TM_CCORR, cv2.TM_CCORR_NORMED, cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]
```
OpenCV recommends that you utilize all the methods and take the best matching algorithm as your final approach.

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

#methods list

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 [cv22.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()
```
What this will do is to move around the template around the base image and return how good of a match it finds in each area. Results will return, (W_base - W_temp + 1, H_base - H_temp + 1) size array.

With the location information, we can draw a shape on the coordinate location. SQDIFF methods use min_loc. All other methods use max_loc.


Object Detection (Template Matching)

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)

Learn Before

Related

Learn After