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`.

Object Detection (Template Matching)

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.

Shi-Tomasi Corner Detection with OpenCV

This classification organizes OpenCV techniques that build on basic image handling: HSV-based color extraction, contour analysis, face and eye detection, template matching for object detection, and Shi-Tomasi corner detection.

University of Michigan - Ann Arbor

Google

OpenCV is a very useful tool for image recognition. It is often used in tandem with machine learning libraries, but also allow for relatively simple image manipulation tools such as rotating, resizing and changing data values. 

The child nodes will break into Basic Tools and Advanced Concepts.

Computer Vision with OpenCV

Basic Tools and Concepts include:
- Conceptual Data Storage in OpenCV
- Import
- Resize
- Display
- Rotate
- Alpha Values
- File Management
- Slicing / Copying
- Live Camera Importing


Learn Before

Related

Learn After