```
(x1, y1)  (x2, y2)
sqrt((x2-x1)^2 + (y2-y1)^2)
```

This will take the coordinate location to measure the distance between two points. 

Euclidean Distance

Once we are given the numpy array of floating point coordinates for the corners, we would want o convert it from floating points to ints. The ravel method will flatten the array. Flattening an array will remove the interior arrays, [[0,1][2,3]] -> [0,1,2,3].
```python
corners = np.int0(corners)

for corner in corners:
        x,y = corner.ravel()
        cv2,circle(img, (x,y), 5, (255, 0, 0), -1)
```
Remember that if your img file is still in gray scaled the color parameter will not be able to display correctly when drawing the corners.

We can also make these corners more obvious by drawing lines between the 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)
```
We will only need the [0] indexing if we don't flatten the array. 

Drawing Corners

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. 

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 

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)

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. 

Learn Before

Related

Learn After