Python OpenCV: flujo óptico con método Lucas-Kanade

Requisitos previos: OpenCV

OpenCV es una enorme biblioteca de código abierto para visión artificial, aprendizaje automático y procesamiento de imágenes. OpenCV admite una amplia variedad de lenguajes de programación como Python, C++, Java, etc. Puede procesar imágenes y videos para identificar objetos, rostros o incluso la escritura a mano de un ser humano. Cuando se integra con varias bibliotecas, como Numpy, que es una biblioteca altamente optimizada para operaciones numéricas, la cantidad de armas aumenta en su arsenal, es decir, cualquier operación que se pueda hacer en Numpy se puede combinar con OpenCV.

En este artículo, aprenderemos cómo aplicar el método Lucas-Kanade para rastrear algunos puntos en un video. Para rastrear los puntos, primero, necesitamos encontrar los puntos a rastrear. Para encontrar los puntos, usaremos cv2.goodFeaturesToTrack(). Ahora, capturaremos el primer cuadro y detectaremos algunos puntos de esquina. Estos puntos se rastrearán utilizando el algoritmo Lucas-Kanade proporcionado por OpenCV, es decir, cv2.calcOpticalFlowPyrLK().

Sintaxis: cv2.calcOpticalFlowPyrLK(prevImg, nextImg, prevPts, nextPts[, winSize[, maxLevel[, criteria]]])

Parámetros:
prevImg : primera imagen de entrada de 8 bits
nextImg : segunda imagen de entrada
prevPts : vector de puntos 2D para los que se debe encontrar el flujo.
winSize : tamaño de la ventana de búsqueda en cada nivel de pirámide.
maxLevel : número de nivel de pirámide máximo basado en 0; si se establece en 0, no se utilizan pirámides (un solo nivel), si se establece en 1, se utilizan dos niveles, y así sucesivamente.
criterio : parámetro que especifica el criterio de terminación del algoritmo de búsqueda iterativa.

Retorno:
nextPts : vector de salida de puntos 2D (con coordenadas de punto flotante de precisión simple) que contiene las nuevas posiciones calculadas de las entidades de entrada en la segunda imagen; cuando se pasa el indicador OPTFLOW_USE_INITIAL_FLOW, el vector debe tener el mismo tamaño que en la entrada.
estado : vector de estado de salida (de caracteres sin firmar); cada elemento del vector se establece en 1 si se ha encontrado el flujo para las características correspondientes; de lo contrario, se establece en 0.
err : vector de salida de errores; cada elemento del vector se establece en un error para la característica correspondiente, el tipo de medida de error se puede establecer en el parámetro de banderas; si no se encontró el flujo, entonces el error no está definido (use el parámetro de estado para encontrar tales casos).

Ejemplo:

import numpy as np
import cv2
  
cap = cv2.VideoCapture('sample.mp4')
  
# params for corner detection
feature_params = dict( maxCorners = 100,
                       qualityLevel = 0.3,
                       minDistance = 7,
                       blockSize = 7 )
  
# Parameters for lucas kanade optical flow
lk_params = dict( winSize = (15, 15),
                  maxLevel = 2,
                  criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT,
                              10, 0.03))
  
# Create some random colors
color = np.random.randint(0, 255, (100, 3))
  
# Take first frame and find corners in it
ret, old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame,
                        cv2.COLOR_BGR2GRAY)
p0 = cv2.goodFeaturesToTrack(old_gray, mask = None,
                             **feature_params)
  
# Create a mask image for drawing purposes
mask = np.zeros_like(old_frame)
  
while(1):
      
    ret, frame = cap.read()
    frame_gray = cv2.cvtColor(frame,
                              cv2.COLOR_BGR2GRAY)
  
    # calculate optical flow
    p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray,
                                           frame_gray,
                                           p0, None,
                                           **lk_params)
  
    # Select good points
    good_new = p1[st == 1]
    good_old = p0[st == 1]
  
    # draw the tracks
    for i, (new, old) in enumerate(zip(good_new, 
                                       good_old)):
        a, b = new.ravel()
        c, d = old.ravel()
        mask = cv2.line(mask, (a, b), (c, d),
                        color[i].tolist(), 2)
          
        frame = cv2.circle(frame, (a, b), 5,
                           color[i].tolist(), -1)
          
    img = cv2.add(frame, mask)
  
    cv2.imshow('frame', img)
      
    k = cv2.waitKey(25)
    if k == 27:
        break
  
    # Updating Previous frame and points 
    old_gray = frame_gray.copy()
    p0 = good_new.reshape(-1, 1, 2)
  
cv2.destroyAllWindows()
cap.release()

Producción: