Diferencias

Muestra las diferencias entre dos versiones de la página.

--- informatica:programacion:python:modulos:opencv [2020/12/10 14:29] – [Template matching] tempwin
+++ informatica:programacion:python:modulos:opencv [2020/12/10 16:30] (actual) – [Optical Flow] tempwin
@@ Línea 133: / Línea 133: @@
 </code>
+Podemos convertirlo en una función para utilizarlo más cómodamente:
+<code python>
+def display(img):
+    dig = plt.figure(figsize=(10,8))
+    ax = fig.add_subplot(111)
+    new_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    ax.imgshow(new_img)
+# Para usarla:
+img = cv2.imread("imagen.jpg")
+display(img)
+</code>
 ===== Imágenes en OpenCV =====
@@ Línea 770: / Línea 783: @@
 Con este método detectaremos si existe alguna cara en una imagen, aunque no a quién pertenece ya que eso es parte de deep learning.
+El algoritomo Haar cascades en lugar de recorrer la imagen en busca de una imagen, pasa una cascada de clasificadores.
+Pasos:
+  * Imagen con una cara mirando hacia la cámara
+  * Convertir la imagen a escala de grises
+  * Comienza la búsqueda de características Haar Cascade
+    * Primero los ojos
+    * Luego el tabique nasal
+    * ...
+La búsqueda se hace con la idea de características de línea y de filo/margen
+Cuando la imagen pasa todos los clasificadores, se puede concluir que se ha detectado una cara.
+El problema de este método es que necesita un conjunto muy grande de información. La parte buena es que OpenCV [[https://github.com/opencv/opencv/tree/master/data/haarcascades|viene con ficheros XML pre-entrenados para Haar]].
+<code python>
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+%matplotlib inline
+# Leemos una imagen en escala de grises
+nadia = cv2.imread("nadia.jpg", 0)
+plt.imshow(nadia, cmap='gray')
+# El siguiente clasificador es una lista de 6000 características que definen una cara de frente
+face_cascade = cv2.CascadeClassifier("../101/DATA/haarcascades/haarcascade_frontalface_default.xml")
+def detect_face(img):
+    face_img = img.copy()
+    face_rects = face_cascade.detectMultiScale(face_img)
+    # El método anterior devuelve un objeto que utilizaremos
+    # para dibujar un rectángulo alrededor de la cara
+    for (x,y,w,h) in face_rects:
+        cv2.rectangle(face_img,(x,y),(x+w,y+h), (255,255,255), 10)
+    return face_img
+result = detect_face(nadia)
+# Mostramos la imagen resultante con el rectángulo sobre la cara
+plt.imshow(result, cmap='gray')
+</code>
+Si no se detectasen las caras correctamente o hubiese duplicidades, se puede jugar con el factor de escala o el parámetro de vecinos:
+<code python>
+# Mejora
+def adj_detect_face(img):
+    face_img = img.copy()
+    face_rects = face_cascade.detectMultiScale(face_img, scaleFactor = 1.2, minNeighbors=5)
+    # El método anterior devuelve un objeto que utilizaremos
+    # para dibujar un rectángulo alrededor de la cara
+    for (x,y,w,h) in face_rects:
+        cv2.rectangle(face_img,(x,y),(x+w,y+h), (255,255,255), 10)
+    return face_img
+</code>
+==== Detección de ojos ====
+<code python>
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+%matplotlib inline
+nadia = cv2.imread("../101/DATA/Nadia_Murad.jpg", 0)
+# Utilizamos otro clasificador
+eye_cascade = cv2.CascadeClassifier("../101/DATA/haarcascades/haarcascade_eye.xml")
+# Función para detectar los ojos y pintar un recuadro
+def detect_eyes(img):
+    face_img = img.copy()
+    eyes_rects = eye_cascade.detectMultiScale(face_img)
+    # El método anterior devuelve un objeto que utilizaremos
+    # para dibujar un rectángulo alrededor de los ojos
+    for (x,y,w,h) in eyes_rects:
+        cv2.rectangle(face_img,(x,y),(x+w,y+h), (255,255,255), 10)
+    return face_img
+result = detect_eyes(nadia)
+plt.imshow(result, cmap='gray')
+</code>
+<WRAP center round tip 60%>
+Igual que en la detección de caras, podemos jugar con los argumentos del método ''detectMultiScale'' para mejorar los resultados
+</WRAP>
+==== Detección de caras en vídeo ====
+<code python>
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+%matplotlib inline
+# Capturamos vídeo de la primera fuente del PC
+cap = cv2.VideoCapture(0)
+# Función de detección de imágenes
+def detect_face(img):
+    face_img = img.copy()
+    face_rects = face_cascade.detectMultiScale(face_img)
+    for (x,y,w,h) in face_rects:
+        cv2.rectangle(face_img,(x,y),(x+w,y+h), (255,255,255), 10)
+    return face_img
+while True:
+    ret, frame = cap.read(0)
+    frame = detect_face(frame)
+    cv2.imshow('Video Face Detector', frame)
+    k = cv2.waitKey(1)
+    if k == ord('q'):
+        break
+cap.release()
+cv2.destroyAllWindows()
+</code>
+===== Seguimiento de objetos =====
+Técnicas:
+  * Optical Flow
+  * MeanShift y CamShift
+==== Optical Flow ====
+Los métodos de OpenCV parten de un conjunto de puntos y un frame y luego intenta encontrar esos puntos en el siguiente frame.
+Dos algoritmos:
+  * Lucas-Kanade
+  * Gunner Farneback: si queremos seguir todos los puntos de un vídeo.
+<code python>
+cap = cv2.VideoCapture(0)
+ret, prev_frame = cap.read()
+# Primer frame
+prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2RGB)
+# Puntos a seguir
+prevPts = cv2.goodFeaturesToTrack(prev_gray, mask = None, **corner_track_params)
+mask = np.zeros_like(prev_frame)
+while True:
+    ret, frame = cap.read()
+    frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    # Calculamos el optical flow entre frames
+    nextPts, status, err = cv2.calcOpticalFlowPyrLK(prev_gray, frame_gray, prevPts, None, **lk_params)
+    good_new = nextPts[status == 1]
+    good_prev = prevPts[status == 1]
+    for i, (new, prev) in enumerate(zip(good_new, good_prev)):
+        x_new, y_new = new.ravel()
+        x_prev, y_prev = prev.ravel()
+        mask = cv2.line(mask, (x_new, y_new), (x_prev, y_prev), (0,255,0),3)
+        frame = cv2.circle(frame, (x_new, y_new), 8, (0,0,255), -1)
+    img = csv2.add(frame, mask)
+    cv2.imshow('tracking', img)
+    k = cv2.waitKey(30) & 0xFF
+    if k == ord('q'):
+        break;
+    prev_grey = frame_gray.copy()
+    prevPts = good_new.reshape(-1, 1, 2)
+cv2.destroyAllWindows()
+cap.release()
+</code>