Python OpenCV: ¿Detecta una dirección general de movimiento?

Question

Todavía estoy pirateando un script de escaneo de libros, y por ahora, todo lo que necesito es poder detectar automágicamente un giro de página. El libro llena el 90% de la pantalla (estoy usando una webcam cruddy para la detección de movimiento), así que cuando giro una página, la dirección del movimiento es básicamente en la misma dirección.

he modificado una secuencia de comandos de movimiento de seguimiento, pero derivados está recibiendo ninguna parte de mí:

#!/usr/bin/env python 

import cv, numpy 

class Target: 
    def __init__(self): 
     self.capture = cv.CaptureFromCAM(0) 
     cv.NamedWindow("Target", 1) 

    def run(self): 
     # Capture first frame to get size 
     frame = cv.QueryFrame(self.capture) 
     frame_size = cv.GetSize(frame) 
     grey_image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1) 
     moving_average = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_32F, 3) 
     difference = None 
     movement = [] 

     while True: 
      # Capture frame from webcam 
      color_image = cv.QueryFrame(self.capture) 

      # Smooth to get rid of false positives 
      cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0) 

      if not difference: 
       # Initialize 
       difference = cv.CloneImage(color_image) 
       temp = cv.CloneImage(color_image) 
       cv.ConvertScale(color_image, moving_average, 1.0, 0.0) 
      else: 
       cv.RunningAvg(color_image, moving_average, 0.020, None) 

      # Convert the scale of the moving average. 
      cv.ConvertScale(moving_average, temp, 1.0, 0.0) 

      # Minus the current frame from the moving average. 
      cv.AbsDiff(color_image, temp, difference) 

      # Convert the image to grayscale. 
      cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY) 

      # Convert the image to black and white. 
      cv.Threshold(grey_image, grey_image, 70, 255, cv.CV_THRESH_BINARY) 

      # Dilate and erode to get object blobs 
      cv.Dilate(grey_image, grey_image, None, 18) 
      cv.Erode(grey_image, grey_image, None, 10) 

      # Calculate movements 
      storage = cv.CreateMemStorage(0) 
      contour = cv.FindContours(grey_image, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE) 
      points = [] 

      while contour: 
       # Draw rectangles 
       bound_rect = cv.BoundingRect(list(contour)) 
       contour = contour.h_next() 

       pt1 = (bound_rect[0], bound_rect[1]) 
       pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3]) 
       points.append(pt1) 
       points.append(pt2) 
       cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255,0,0), 1) 

      num_points = len(points) 

      if num_points: 
       x = 0 
       for point in points: 
        x += point[0] 
       x /= num_points 

       movement.append(x) 

      if len(movement) > 0 and numpy.average(numpy.diff(movement[-30:-1])) > 0: 
       print 'Left' 
      else: 
       print 'Right' 

      # Display frame to user 
      cv.ShowImage("Target", color_image) 

      # Listen for ESC or ENTER key 
      c = cv.WaitKey(7) % 0x100 
      if c == 27 or c == 10: 
       break 

if __name__=="__main__": 
    t = Target() 
    t.run() 

detecta el movimiento medio del centro de la media de todas las cajas, que es extremadamente ineficiente. ¿Cómo podría detectar estos movimientos de forma rápida y precisa (es decir, dentro de un umbral)?

Estoy usando Python, y planeo seguir con esto, ya que todo mi framework está basado en Python.

Y se agradece la ayuda, así que gracias a todos por adelantado. Aclamaciones.

Answer 1

No he usado OpenCV en Python antes, solo un poco en C++ con openframeworks.

Para esto supongo que OpticalFlow funcionarán las propiedades velty.

Para obtener más información sobre cómo funciona el flujo óptico, consulte this paper.

HTH

Answer 2

¿Por qué no usar cv.GoodFeaturesToTrack? puede resolver el tiempo de ejecución del script ... y acortar el código ...