Edge Detection

We will cover techniques that are used in object detection.
We already have all the assets from previous pages so let’s dive in with the code
We will turn the camera on and send the feed to the window to view. The filtering is controlled by using the letters on the keyboard specified in the code
We will manipulate the blurring of the image, this could be used for feature extraction. Some extraction is done while blurring an image to make other edges stand out
We will also view the corner detection features - this is done by holding a sheet with printed text on them and seeing how the corners are detected. Notice the effect of corner detection on larger letters, as well as blended in letters as opposed to clear definitive letters
We will finally look at the CANNY edge detection - which makes the image all dark except for the outline/edges of objects. The threshold for the detection can be changed from 80 to 145 which makes the two values closer will effect how sharp the detection is. So the wider the numbers are as they are now 80-145 should provide a more distinct detection. Tuning is dependent on the application
I will explain the logic behind the code

We start off by defining the 4 different run modes for the scrip which include Preview, … CANNY Edge
Set the dictionary for the corner features parameters
1. Max number of corners to be returned
2. Max value for the threshold to be detected. SO if you had a max value of features detected to be 100 then the max features corners would be 100X0.2=20 which would be the threshold of whether a featured corner was detected
3. Min Distance between adjacent corners measured in pixel space
4. Blocksize is the size of the pixel neighborhood used by the algorithm for computing the featured corners
In the Last feature below in the code, we use cv2.cvtColor() to convert the image to grayscale, and then we use goodFeaturesToTrack() to generate the Corners.
The list of corners are shown using green circles on the image and send it to the output screen

import cv2
import sys
import numpy

PREVIEW  = 0  # Preview Mode
BLUR     = 1  # Blurring Filter
FEATURES = 2  # Corner Feature Detector
CANNY    = 3  # Canny Edge Detector

feature_params = dict(maxCorners=500, qualityLevel=0.2, minDistance=15, blockSize=9)

# Setup the camera feed using the local device similar to what we did in an earlier page
s = 0
#if len(sys.argv) > 1:
#bbbbbbbbbbbbbbbbbbbbbbbbbbbbf    s = sys.argv[1]

image_filter = PREVIEW
alive = True

win_name = "Camera Filters"
cv2.namedWindow(win_name, cv2.WINDOW_NORMAL)
result = None

source = cv2.VideoCapture(s)


# Read the first frame of the video

while alive:
    has_frame, frame = source.read()
    if not has_frame:
        break

# Flip the video horizontally so it's easier to point and image will not be reversed as I watch it
    frame = cv2.flip(frame, 1)
    
    
# Here depending on the user input, we will perform one of the functions in opencv

# In preview mode we just send that frame into result and send it to cv2.imshow() to diplay it. If any other option we process the result first then send the processed result to display it
    if image_filter == PREVIEW:
        result = frame
    elif image_filter == CANNY:
        result = cv2.Canny(frame, 80, 150)  #lower & upper threshold anything above will be used as edge, if below it's discarded
    elif image_filter == BLUR:
        result = cv2.blur(frame, (13, 13)) #dimension for blur box kernel, smaller size results in less blurring
    elif image_filter == FEATURES:
        result = frame
        frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        corners = cv2.goodFeaturesToTrack(frame_gray, **feature_params)
        if corners is not None:
            for x, y in numpy.float32(corners).reshape(-1, 2):
                cv2.circle(result, (x, y), 10, (0, 255, 0), 1)

    cv2.imshow(win_name, result)

# Next section is to wait for user input on the keyboard
    key = cv2.waitKey(1)
    if key == ord("Q") or key == ord("q") or key == 27:
        alive = False
    elif key == ord("C") or key == ord("c"):
        image_filter = CANNY
    elif key == ord("B") or key == ord("b"):
        image_filter = BLUR
    elif key == ord("F") or key == ord("f"):
        image_filter = FEATURES
    elif key == ord("P") or key == ord("p"):
        image_filter = PREVIEW

source.release()
cv2.destroyWindow(win_name)

CANNY Detection