add opencv practices

Author: sevdaimany

Computer Vision Masterclass/Examples/camera.py

@@ -0,0 +1,28 @@
+import cv2
+
+face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
+
+video_capture = cv2.VideoCapture(0)
+
+while True:
+    # Capture frame-by-frame
+    ret, frame = video_capture.read()
+
+    image_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+    detections = face_detector.detectMultiScale(image_gray, minSize=(100,100))
+
+    # Draw a rectangle around the faces
+    for (x, y, w, h) in detections:
+        print(w, h)
+        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
+
+    # Display the resulting frame
+    cv2.imshow('Video', frame)
+
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# When everything is done, release the capture
+video_capture.release()
+cv2.destroyAllWindows()

Computer Vision Masterclass/Examples/camera_lbph.py

@@ -0,0 +1,31 @@
+import cv2
+
+face_detector = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")
+face_recognizer = cv2.face.LBPHFaceRecognizer_create()
+face_recognizer.read("lbph_classifier.yml")
+width, height = 220, 220
+font = cv2.FONT_HERSHEY_COMPLEX_SMALL
+camera = cv2.VideoCapture(0)
+
+while (True):
+    connected, image = camera.read()
+    image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    detections = face_detector.detectMultiScale(image_gray, scaleFactor=1.5, minSize=(30,30))
+    for (x, y, w, h) in detections:
+        image_face = cv2.resize(image_gray[y:y + w, x:x + h], (width, height))
+        cv2.rectangle(image, (x, y), (x + w, y + h), (0,0,255), 2)
+        id, confidence = face_recognizer.predict(image_face)
+        name = ""
+        if id == 1:
+            name = 'Jones'
+        elif id == 2:
+            name = 'Gabriel'
+        cv2.putText(image, name, (x,y +(w+30)), font, 2, (0,0,255))
+        cv2.putText(image, str(confidence), (x,y + (h+50)), font, 1, (0,0,255))
+
+    cv2.imshow("Face", image)
+    if cv2.waitKey(1) == ord('q'):
+        break
+
+camera.release()
+cv2.destroyAllWindows()

Computer Vision Masterclass/Examples/object_tracking.py

@@ -0,0 +1,33 @@
+import cv2
+
+#tracker = cv2.TrackerKCF_create()
+tracker = cv2.TrackerCSRT_create()
+
+video = cv2.VideoCapture('street.mp4')
+ok, frame = video.read()
+
+bbox = cv2.selectROI(frame)
+#print(bbox)
+
+ok = tracker.init(frame, bbox)
+#print(ok)
+
+while True:
+    ok, frame = video.read()
+    #print(ok)
+    if not ok:
+        break
+    ok, bbox = tracker.update(frame)
+    #print(bbox)
+    #print(ok)
+
+    if ok:
+        (x, y, w, h) = [int(v) for v in bbox]
+        cv2.rectangle(frame, (x, y), (x + w, y + h), (0,255,0), 2, 1)
+    else:
+        cv2.putText(frame, 'Error', (100, 80), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,255), 2)
+
+    cv2.imshow('Tracking', frame)
+    if cv2.waitKey(1) & 0XFF == 27: # ESC
+        break
+

Computer Vision Masterclass/PyCharm/body_extractor.py

@@ -0,0 +1,156 @@
+pontos = []
+
+def verificar_bracos_ACIMA(pontos):
+    # BRAÇO ESQUERDO
+    # posição horizontal
+    cabeca_V = 0
+    punhoEsquerdo_H = 0
+    # posição veritical
+    ombroEsquerdo_H = 0
+    punhoEsquerdo_V = 0
+
+    # BRAÇO DIREITO
+    # posição horizontal
+    punhoDireito_H = 0
+    # posição veritical
+    punhoDireito_V = 0
+    ombroDireito_H = 0
+
+    for indx, p in enumerate(pontos):
+        # BRAÇOS
+        # 0 ao 8 - ESQUERDO
+        # 0 ao 5 - DIREITO
+        # print(indx, p)
+        # p[0] é na horizontal
+        # p[1] é na vertical
+
+        # CABEÇA
+        if indx == 0:
+            cabeca_V = p[1]
+
+        # OMBRO DIREITO
+        elif indx == 2:
+            ombroDireito_H = p[0]
+
+        # PUNHO DIREITO
+        elif indx == 4:
+            punhoDireito_H = p[0]
+            punhoDireito_V = p[1]
+
+        # OMBRO ESQUERDO
+        elif indx == 5:
+            ombroEsquerdo_H = p[0]
+
+        # PUNHO ESQUERDO
+        elif indx == 7:
+            punhoEsquerdo_H = p[0]
+            punhoEsquerdo_V = p[1]
+
+    # quanto menor a posição da altura, mais alto o ponto está
+    # quanto maior a posição da altura, mais baixo o ponto está
+    # COMPARANDO NA VERITICAL
+    if punhoEsquerdo_V and punhoDireito_V < cabeca_V:
+        # print('Punho acima da cabeça')
+        # COMPARANDO NA HORIZONTAL
+        if (punhoEsquerdo_H <= ombroEsquerdo_H) and (punhoDireito_H >= ombroDireito_H):
+            #     # print('Punhos passaram da linha do ombro')
+            return True
+    else:
+        return False
+
+
+def verificar_bracos_ABAIXO(pontos):
+    # BRAÇO ESQUERDO
+    # posição horizontal
+    punhoEsquerdo_H = 0
+    # posição veritical
+    ombroEsquerdo_H = 0
+    ombroEsquerdo_V = 0
+    punhoEsquerdo_V = 0
+
+    # BRAÇO DIREITO
+    # posição horizontal
+    # posição veritical
+    punhoDireito_V = 0
+    ombroDireito_H = 0
+
+    for indx, p in enumerate(pontos):
+        # OMBRO DIREITO
+        if indx == 2:
+            ombroDireito_H = p[0]
+            ombroDireito_V = p[1]
+
+        # PUNHO DIREITO
+        if indx == 4:
+            punhoDireito_V = p[1]
+
+        # OMBRO ESQUERDO
+        if indx == 5:
+            ombroEsquerdo_H = p[0]
+            ombroEsquerdo_V = p[1]
+
+        # PUNHO ESQUERDO
+        if indx == 7:
+            punhoEsquerdo_V = p[1]
+            punhoEsquerdo_H = p[0]
+
+    if (punhoEsquerdo_V >= ombroEsquerdo_V) and (punhoDireito_V >= ombroDireito_V):
+        if (punhoEsquerdo_H <= ombroEsquerdo_H) and (punhoEsquerdo_H >= ombroDireito_H):
+            print('posicao inicial')
+            return True
+    else:
+        return False
+
+
+def verificar_pernas_AFASTADAS(pontos):
+    # PERNAS
+    # 11 ao 14 a esquerda
+    # 8 ao 11 a direita
+    tornozeloEsquerdo_H = 0
+    tornozeloDireito_H = 0
+    quadrilEsquerdo_H = 0
+    quadrilDireito_H = 0
+
+    for indx, p in enumerate(pontos):
+        # print(indx, p)
+        # p[0] é na horizontal
+        # p[1] é na vertical
+        if indx == 0:
+            quadrilDireito_H = p[0]
+        if indx == 2:
+            tornozeloDireito_H = p[0]
+        if indx == 3:
+            quadrilEsquerdo_H = p[0]
+        if indx == 5:
+            tornozeloEsquerdo_H = p[0]
+    if (tornozeloDireito_H < quadrilDireito_H) and (tornozeloEsquerdo_H > quadrilEsquerdo_H):
+        return True
+    else:
+        return False
+
+
+def verificar_pernas_JUNTAS(pontos):
+    # PERNAS
+    # 11 ao 14 a esquerda
+    # 8 ao 11 a direita
+    tornozeloEsquerdo_H = 0
+    tornozeloDireito_H = 0
+    quadrilEsquerdo_H = 0
+    quadrilDireito_H = 0
+
+    for indx, p in enumerate(pontos):
+        # print(indx, p)
+        # p[0] é na horizontal
+        # p[1] é na vertical
+        if indx == 0:
+            quadrilDireito_H = p[0]
+        if indx == 2:
+            tornozeloDireito_H = p[0]
+        if indx == 3:
+            quadrilEsquerdo_H = p[0]
+        if indx == 5:
+            tornozeloEsquerdo_H = p[0]
+    if (tornozeloDireito_H >= quadrilDireito_H) and (tornozeloEsquerdo_H <= quadrilEsquerdo_H):
+        return True
+    else:
+        return False

Computer Vision Masterclass/PyCharm/camera.py

@@ -0,0 +1,29 @@
+import cv2
+
+face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
+
+video_capture = cv2.VideoCapture(0)
+
+while True:
+    # Capture frame-by-frame
+    ret, frame = video_capture.read()
+
+    image_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+    detections = face_detector.detectMultiScale(image_gray, minSize=(100, 100),
+                                                minNeighbors=5)
+
+    # Draw a rectangle around the faces
+    for (x, y, w, h) in detections:
+        print(w, h)
+        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
+
+    # Display the resulting frame
+    cv2.imshow('Video', frame)
+
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+# When everything is done, release the capture
+video_capture.release()
+cv2.destroyAllWindows()

Computer Vision Masterclass/PyCharm/video_functions.py

@@ -0,0 +1,90 @@
+import cv2
+import random
+import numpy as np
+	
+## Generate random colors
+def random_colors(N, seed, bright=True):
+    import colorsys
+    # To get visually distinct colors, we generate them in HSV space then convert to RGB. 
+    brightness = 1.0 if bright else 0.7
+    hsv = [(i / N, 1, brightness) for i in range(N)]
+    colors = list(map(lambda c: colorsys.hsv_to_rgb(*c), hsv))
+    random.Random(seed).shuffle(colors)
+    return colors
+
+## Apply mask to image 
+def apply_mask(image, mask, color, alpha=0.5):
+    for c in range(3):
+        image[:, :, c] = np.where(
+                mask == 1,
+                image[:, :, c] *
+                (1 - alpha) + alpha * color[c] * 255,
+                image[:, :, c])
+    return image
+
+## Display the instances (segmenteded objects)
+def display_instances(image, boxes, masks, class_ids, class_names,
+                      scores=None, title="", figsize=(16, 16), ax=None,
+                      show_mask=True, show_bbox=True, colors=None, captions=None):
+    from matplotlib import patches, lines
+    from skimage.measure import find_contours
+    from matplotlib.patches import Polygon
+    
+    # Number of instances
+    N = boxes.shape[0]
+    if not N:
+        print("\n*** No instances to display *** \n")
+    else:
+        assert boxes.shape[0] == masks.shape[-1] == class_ids.shape[0]
+
+    # Generate random colors
+    colors = colors or random_colors(N)
+
+    height, width = image.shape[:2]
+
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+    masked_image = image.astype(np.uint32).copy()
+
+    for i in range(N):
+        color = colors[class_ids[i]]
+
+        # Bounding box
+        if not np.any(boxes[i]):
+            # Skip this instance. Has no bbox. Likely lost in image cropping.
+            continue
+        y1, x1, y2, x2 = boxes[i]
+        if show_bbox:
+            p = patches.Rectangle((x1, y1), x2 - x1, y2 - y1, linewidth=2,
+                                alpha=0.7, linestyle="dashed",
+                                edgecolor=color, facecolor='none')
+
+        # Label
+        if not captions:
+            class_id = class_ids[i]
+            score = scores[i] if scores is not None else None
+            label = class_names[class_id]
+            caption = "{} {:.3f}".format(label, score) if score else label
+        else:
+            caption = captions[i]
+        masked_image = cv2.putText(np.float32(masked_image), caption, (x1, y1), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255,255,255), 1)
+
+        # Mask
+        mask = masks[:, :, i]
+        if show_mask:
+            masked_image = apply_mask(masked_image, mask, color)
+
+        # Mask Polygon
+        # Pad to ensure proper polygons for masks that touch image edges.
+        padded_mask = np.zeros(
+            (mask.shape[0] + 2, mask.shape[1] + 2), dtype=np.uint8)
+        padded_mask[1:-1, 1:-1] = mask
+        contours = find_contours(padded_mask, 0.5)
+        for verts in contours:
+            # Subtract the padding and flip (y, x) to (x, y)
+            verts = np.fliplr(verts) - 1
+            p = Polygon(verts, facecolor="none", edgecolor=color)
+
+    return masked_image.astype(np.uint8)
+
+# the functions are based on: https://github.com/matterport/Mask_RCNN/blob/master/mrcnn/visualize.py