Sugerencias ... Si buscas algún código de programación en especifico , solo escribe alguna palabra relacionada , como por ejemplo : Calculadora , Metodo , Burbuja , Applets ... etc

Buscar

Abr
03

Pyramid Lucas-Kanade optical flow code

Autor :  Duvallier

En el ámbito de la Visión Artificial, el primer aspecto trata de dar solución a la problemática de la extracción de características de imágenes de forma estática. Entidades como contornos, huecos o cambios en la zona de intensidad pueden ser detectados de una manera cómoda, utilizando generalmente una sola imagen.

Sin duda éste es el paso previo al estudio de la escena a partir de un conjunto de imágenes tomadas de forma separada en el tiempo y, en general, desde distintos puntos de vista.

Con el estudio de una secuencia de imágenes, se pretende estudiar la evolución temporal de los objetos que son capturados por la cámara, para tratar de extraer la mayor cantidad de características de los mismos.

Una de las principales características que puede ser extraída de una secuencia de imágenes es, con mucha diferencia, la velocidad de un objeto. Mediante esta característica, es posible tener una noción diferencial de la posición que tendrá el objeto en el siguiente instante y poder predecir, de esa forma, posibles choques entre objetos o movimientos relativos de la cámara.

Las técnicas de Optical Flow tratan de dar solución a la determinación de la velocidad de los objetos dentro de la secuencia de imágenes.

C++:
  1. // Pyramid L-K optical flow example
  2. //
  3. #include "stdafx.h"
  4. #include <cv.h>
  5. #include <cxcore.h>
  6. #include <highgui.h>
  7. const int MAX_CORNERS = 500;
  8.  
  9.  
  10. int main(int argc, char** argv) {
  11. // Initialize, load two images from the file system, and
  12. // allocate the images and other structures we will need for
  13. // results.
  14. //
  15.  
  16.     // Obtener Imagenes
  17.     IplImage* imgA = cvLoadImage("image0.jpg",CV_LOAD_IMAGE_GRAYSCALE);
  18.     IplImage* imgB = cvLoadImage("image1.jpg",CV_LOAD_IMAGE_GRAYSCALE);
  19.    
  20.     // Tamaño de las Imagenes
  21.     CvSize img_sz = cvGetSize( imgA );
  22.    
  23.     //
  24.     int win_size = 10;
  25.     IplImage* imgC = cvLoadImage("image1.jpg",CV_LOAD_IMAGE_UNCHANGED);
  26.  
  27. // The first thing we need to do is get the features
  28. // we want to track.
  29. //
  30.  
  31.     IplImage* eig_image = cvCreateImage( img_sz, IPL_DEPTH_32F, 1 );
  32.     IplImage* tmp_image = cvCreateImage( img_sz, IPL_DEPTH_32F, 1 );
  33.  
  34.     int corner_count = MAX_CORNERS;
  35.  
  36.     CvPoint2D32f* cornersA = new CvPoint2D32f[ MAX_CORNERS ];
  37.  
  38.     cvGoodFeaturesToTrack(
  39.         imgA,
  40.         eig_image,
  41.         tmp_image,
  42.         cornersA,
  43.         &corner_count,
  44.         0.01,
  45.         5.0,
  46.         0,
  47.         3,
  48.         0,
  49.         0.04
  50.         );
  51.  
  52.     cvFindCornerSubPix(
  53.         imgA,
  54.         cornersA,
  55.         corner_count,
  56.         cvSize(win_size,win_size),
  57.         cvSize(-1,-1),
  58.         cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,20,0.03)
  59.     );
  60.  
  61.     // Call the Lucas Kanade algorithm
  62.  
  63.     char features_found[ MAX_CORNERS ];
  64.     float feature_errors[ MAX_CORNERS ];
  65.  
  66.     CvSize pyr_sz = cvSize( imgA->width+8, imgB->height/3 );
  67.     IplImage* pyrA = cvCreateImage( pyr_sz, IPL_DEPTH_32F, 1 );
  68.     IplImage* pyrB = cvCreateImage( pyr_sz, IPL_DEPTH_32F, 1 );
  69.  
  70.     CvPoint2D32f* cornersB = new CvPoint2D32f[ MAX_CORNERS ];
  71.  
  72.     cvCalcOpticalFlowPyrLK(
  73.         imgA,
  74.         imgB,pyrA,
  75.         pyrB,
  76.         cornersA,
  77.         cornersB,
  78.         corner_count,
  79.         cvSize( win_size,win_size ),
  80.         5,
  81.         features_found,
  82.         feature_errors,
  83.         cvTermCriteria( CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, .3 ),
  84.         0
  85.     );
  86.  
  87.     // Now make some image of what we are looking at:
  88.  
  89.         for( int i=0; i<corner_count; i++ ) {
  90.             if( features_found[i]==0|| feature_errors[i]>550 ) {
  91.                 printf("Error is %f/n",feature_errors[i]);
  92.                 continue;
  93.             }
  94.  
  95.             printf("Got it/n");
  96.    
  97.             CvPoint p0 = cvPoint(cvRound( cornersA[i].x ),cvRound( cornersA[i].y ));
  98.             CvPoint p1 = cvPoint(cvRound( cornersB[i].x ),cvRound( cornersB[i].y ));
  99.             cvLine( imgC, p0, p1, CV_RGB(255,0,0),2 );
  100.         }
  101.  
  102.         cvNamedWindow("ImageA",0);
  103.         cvNamedWindow("ImageB",0);
  104.         cvNamedWindow("LKpyr_OpticalFlow",0);
  105.  
  106.         cvShowImage("ImageA",imgA);
  107.         cvShowImage("ImageB",imgB);
  108.         cvShowImage("LKpyr_OpticalFlow",imgC);
  109.    
  110.         cvWaitKey(0);
  111. return 0;
  112. }

Etiquetas: ,
Publicado en C y C++, Codes


 1 comentario

Raül :
7 de Septiembre de 2009 a las 7:07

It would be great to know how OpticalFlow detect that points. I mean, which features is using OpticalFlow? (color, texture, light… or what?). It would be nice to separe it, afterwards you can, for example, compare carachterístics of color from one image to another.


 Deja un comentario