universidad tecnologica nacional facultad regional … de palanquillas … · utilizar librería de...

UNIVERSIDAD TECNOLOGICA NACIONAL FACULTAD REGIONAL SAN NICOLAS

INGENIERIA EN ELECTRONICA

PROBLEMA DE INGENIERÍA

TECNICAS DIGITALES III

DETECCIÓN DE PALANQUILLA POR

IMAGENES

Integrantes:

- Bernárdez, Andrés - Ortolani, Javier

Docentes:

- Profesor: Poblete Felipe - Auxiliar: Gonzalez Mariano

AÑO 2013

Técnicas Digitales III – Problema de ingeniería

2

INDICE INDICE .............................................................................................................................................................. 2

OBJETIVOS DEL TRABAJO ................................................................................................................................. 3

MATERIAS INTEGRADAS ................................................................................................................................... 3

POSIBLES APLICACIONES .................................................................................................................................. 3

BIBLIOGRAFÍA .................................................................................................................................................. 3

DESARROLLO .................................................................................................................................................... 3

INTRODUCCIÓN ............................................................................................................................................ 3 TEORÍA DE FUNCIONAMIENTO ...................................................................................................................... 4

Etapa de experimentación........................................................................................................................ 4 Funcionamiento ....................................................................................................................................... 4

CIRCUITOS O DIAGRAMAS ............................................................................................................................ 6 RESULTADOS DE LAS PRUEBAS ...................................................................................................................... 7 CONCLUSIONES .......................................................................................................................................... 13

ANEXOS: ......................................................................................................................................................... 14

LISTADOS DE PROGRAMAS ......................................................................................................................... 14

ANEXO ........................................................................................................................................................... 22

Instalación de la librería: ........................................................................................................................ 22 El Compilador: ....................................................................................................................................... 24 Nota: ..................................................................................................................................................... 27 Funciones de OpenCV utilizadas: ............................................................................................................ 27


3

OBJETIVOS DEL TRABAJO Familiarizarse con procesamiento de imágenes. Utilizar librería de OPEN CV Encontrar un método para localizar la posición de un objeto específico (palanquilla) en una imagen.

MATERIAS INTEGRADAS • Informática 2 • Técnicas Digitales 3

POSIBLES APLICACIONES • Aplicaciones Industriales: Localizar la posición de objetos a través de una cámara para que

luego se pueda aprovechar esta información y aplicar algún proceso en esa posición. • Conteo de objetos automático.

BIBLIOGRAFÍA • Sitios de Internet.

• http://docs.opencv.org/modules/refman.html • http://opencv.org/ • http://www.bloodshed.net/devcpp.html • http://opencv-srf.blogspot.com.ar/2010/09/filtering-images.html

DESARROLLO

INTRODUCCIÓN

La idea comienza a partir de una obervación y una necesidad. Un operario posicionando una especie de brazo, una especie de barra que sirve para empujar a palanquillas (lingotes de acero). El operario debe observar donde están los lingotes, posicionar la barra “empujadora” comandándola eléctricamente y habilitarlo para que empuje. Observando esto se nos ocurrió que el posicionamiento podría ser indicado por un programa de computadora. Nuestro objetivo es brindar un método para encontrar la posición de la palanquilla en foto.


4

TEORÍA DE FUNCIONAMIENTO

Etapa de experimentación Primero tuvimos que familiarizarnos con las funciones de OpenCV. Realizamos una práctica de programas simples donde aprendimos a mostrar imágenes, a filtrarlas, a dibujar, etc. Luego tuvimos que aplicar los conocimientos para resolver el problema. El problema consiste en reconocer las palanquillas del horno en una foto e indicar su posición.

Como se aprecia en la imagen, las palanquillas son cuadradas. El problema se reduce entonces a detectar cuadrados, sin embargo no es una tarea simple especialmente porque la imagen suele tener ruido y los cuadradados no son perfectos. Buscamos distintas alternativas. En principio encaramos el problema tratando de detectar segmentos de rectas que surgen de todos los bordes pero el programa se volvía extremadamente complejo. Luego decidimos agregar plantillas de comparación, buscar un objeto a raíz de una referencia. Hubo varias formas de encarar el problema pero no llegamos a buen puerto. Finalmente conseguimos un programa que cumple con el objetivo.

Funcionamiento Cuando utilizamos plantillas de comparación lo que se hace es buscar un objeto conocido (la plantilla) en una imagen. El problema es que las palanquillas, si bien son cuadradas, no son iguales cuando se las compara por foto, así que no podíamos utilizar una palanquilla como plantilla. Por eso se optó por utilizar una plantilla donde solo hubiera un cuadrado. Luego habría que procesar la imagen para la comparación. Extracción de contorno En las librerías de OpenCV existe una función para filtrar los contornos de la imagen: la función Cany.


5

Al extraer los contornos de la imagen, nos despreocupamos por muchos detalles y por los colores. El resultado es una imagen blanco y negro donde solo figuran los contornos. Procesamiento de la imagen. Una vez que hemos obtenido los contornos, hacemos otros procesamientos. Remarcamos los contornos, aumentando el grosor de las líneas que los representan. La imagen se transforma en una base negra con contornos verdes. Por eso utilizamos como plantilla un cuadrado negro con líneas verdes. Luego coloreamos de rojo algunas zonas negras del fondo para eliminar probabilidad de que la plantilla pudiera coincidir por allí. Hemos tomado como referencia a los pixeles negros del borde derecho de la imagen. Consideramos que forman parte del fondo y pintamos a partir de allí. Comparación con una plantilla Al comparar la plantilla en la imagen, obtenemos muchas posiciones donde hay cierto grado de coincidencia. Como la plantilla no es exactamente igual a ningún contorno de palanquilla nunca obtendremos una coincidencia del 100%. Así que nos manejamos solo con los pixeles más probables. El problema es que obtenemos muchos puntos juntos para cada contorno. Para solucionarlo hacemos una promediación. Promediación de pixeles. Lo primero que hacemos es por cada pixel encontrado, lo marcamos en la imagen con un color azul. Cada conjunto de puntos será una mancha azul. Luego por cada mancha azul, le cambiamos el color a otro tono de azul, promediamos esos puntos, guardamos el promedio y finalmente lo volvemos a colorear de otro tono de azul mas claro. A continuación se mostrará el funcionamiento del programa a través de los diagramas


6

CIRCUITOS O DIAGRAMAS

Las etapas del programa son las siguientes

Abrir imagen

Abrir imagen en blanco y negro

Extraer contornos

Dibujar bordes en un nuevo grafico

Colorear espacios en negro de la imagen nueva

Buscar plantilla en la nueva imagen

Marcar pixeles en los centros de los posibles cuadrados

Colorear pixeles de los centros, contarlos y promediar posición de cada uno

Buscar el de la derecha y usar su posición.


7

RESULTADOS DE LAS PRUEBAS

Este es el programa visto por el usuario: Se pide que se ingrese la dirección del campo (la foto) y la dirección del objetivo (una plantilla patrón)

El campo en este caso será la foto del horno con las palanquillas:


8

El objetivo es un cuadrado negro con bordes verde.

Primer paso obtener los contornos de la imagen

Luego se Colorea un poco el fondo


9

A esta última imagen se le aplica el matchtemplate con el objetivo. La idea es encontrar los cuadrados negros.


10

Una vez detectados los cuadrados se prosigue a marcar el de mas a la derecha. Finalmente se marca en la foto original la posición de la palanquilla.


11

El programa aplicado a otras fotos:


12


13

CONCLUSIONES

Las librerías OpenCV son relativamente fáciles de usar aunque cuesta al principio familiarizarse con las funciones. Existen muchas otras funciones que aún no conocemos. El campo del procesamiento de imágenes es muy interesante pero demanda mucho estudio y dedicación. Es muy potente todo lo que se puede hacer. En algún futuro no muy lejano el procesamiento de imágenes será muy importantes en control de automatizaciones industriales: control de posicionamiento, trayectoria de objetos, detección de defectos, etc. Una sola cámara puede reemplazar varios sensores, por ejemplo.: detectores de posición, detectores de nivel, Medición de la calidad, Medición de temperatura(cámara especial),etc. Además todos aquellos controles que pueden hacer las personas con sus ojos claramente podrían hacerse con una cámara y una computadora.


14

ANEXOS:

LISTADOS DE PROGRAMAS #include <stdio.h> #include <stdlib.h> #include <opencv/cv.h> #include <opencv/highgui.h> // estructura para guardar posicion de los cuadrados encontrados struct cuadrado { int i,j; }cuadrados[20];// Se guardará la posicion de hasta 20 cuadrados int main() { int i,j,x,y,k,ii,jj,color; int isum=0,jsum=0,iprom,jprom,jcomp,icomp,cantidad; int ROIi1,ROIi2,ROIj1,ROIj2; CvFont font; int cantidadcuadrados=0; CvScalar s; double minVal,maxVal,aux; CvPoint minLoc, maxLoc; CvScalar pixel; int encontrado; char direccioncampo[100],direccionobjetivo[100]; CvMemStorage* storage; CvSeq* lines; IplImage * campo, * img2,* obj,*blancyneg,*color_dst,*bordes; printf(" Escriba la direccion del campo(100 caracteres):"); scanf("%s",direccioncampo); printf("La direccion es : [%s]\n",direccioncampo); campo= cvLoadImage(direccioncampo,4); cvNamedWindow("Campo",1); cvShowImage("Campo",campo); cvWaitKey(1);


15

printf(" Escriba la direccion del objetivo(100 caracteres):"); scanf("%s",direccionobjetivo); printf("La direccion es : [%s]\n",direccionobjetivo); obj= cvLoadImage(direccionobjetivo,4); cvNamedWindow("Objetivo",1); cvShowImage("Objetivo",obj); cvWaitKey(1); printf("\n presione una tecla para continuar\n"); getch(); //abrir el archivo en blanco y negro blancyneg= cvLoadImage(direccioncampo,0 ); color_dst = cvLoadImage(direccioncampo,4); //Se pinta toda la imagen de negro. color_dst queda negro cvSet( color_dst, cvScalar(0,0,0,0), NULL); bordes= cvCreateImage(cvGetSize(campo),IPL_DEPTH_8U,1); // Se saca los contornos de la imagen en blanco y negro cvCanny( blancyneg, bordes,100, 50, 3 ); // Se obtienen los contornos lines = 0; storage = cvCreateMemStorage(0); //cvFindContours(CvArr* image, CvMemStorage* storage, CvSeq** first_contour, //int header_size=sizeof(CvContour), int mode=CV_RETR_LIST, int method=CV_CHAIN_APPROX_SIMPLE, CvPoint offset=cvPoint(0,0) ) cvFindContours(bordes, storage, &lines, sizeof(CvContour), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint(0,0) ); // Se dibujan los contornos obtenidos en color_dst (estaba negro). Ahora presentara los contornos en color verde //cvDrawContours(CvArr* img, CvSeq* contour, //CvScalar external_color, CvScalar hole_color, int max_level, int thickness=1, int line_type=8, CvPoint offset=cvPoint(0,0) ) cvDrawContours(color_dst, lines, cvScalar(0,255,0,0),cvScalar(0,255,0,0),2,10,8,cvPoint(0,0)); cvNamedWindow("Lineas",1); cvShowImage("Lineas",color_dst); cvWaitKey(1);


16

// En color_dst se rellena de rojo todo lo negro que toque el borde derecho. // El objetivo es eliminar un poco de negro de la imagen. j=color_dst->width-1; for(i=color_dst->height-1;i>-1;i--) { s=cvGet2D(color_dst,i,j); if(s.val[1]>100) {i--; } else { if(i<color_dst->height-1) cvFloodFill(color_dst, cvPoint(j,i),cvScalar(0,0,255,0),cvScalarAll(0),cvScalarAll(0), NULL,4,NULL ); } } cvNamedWindow("Lineas",1); cvShowImage("Lineas",color_dst); cvWaitKey(1); //Ahora se hace una busqueda de la plantilla en color_dst // Se busca un cuadrado negro con bordes verdes. img2= cvCreateImage(cvSize(campo->width-obj->width+1,campo->height-obj->height+1),IPL_DEPTH_32F,1); printf("Generando mapa de busqueda...\n"); cvMatchTemplate(color_dst, obj, img2, CV_TM_CCOEFF_NORMED ); /*cvNamedWindow("Matching",1); cvShowImage("Matching",img2); */ printf("\npresione una tecla para continuar...\n"); cvWaitKey(1); getch(); /*


17

void cvMinMaxLoc(const CvArr* arr, double* minVal, double* maxVal, CvPoint* minLoc=NULL, CvPoint* maxLoc=NULL, const CvArr* mask=NULL)¶ Finds global minimum and maximum in array or subarray. Parameters: arr – The source array, single-channel or multi-channel with COI set minVal – Pointer to returned minimum value maxVal – Pointer to returned maximum value minLoc – Pointer to returned minimum location maxLoc – Pointer to returned maximum location mask – The optional mask used to select a subarray */ cvMinMaxLoc(img2, &minVal, &maxVal, &minLoc,&maxLoc,NULL); printf("\n\n minVal=%g maxVal=%g",minVal,maxVal); printf("\n\n minLoc x=%d y=%d",minLoc.x,minLoc.y); printf("\n\n maxLoc x=%d y=%d",maxLoc.x,maxLoc.y); printf("\n\n presione una tecla para continuar"); printf("\n"); cvWaitKey(1); getch(); //En la imagen de respuesta del templateMatching buscamos los pixeles que tengan mayor coincidencia con el objetivo // Buscamos los pixeles cuyo valor sea mayor a 0.5 //------------- ROIi1=1; ROIi2=img2->height-1; ROIj1=1; ROIj2=img2->width-1; encontrado=0; for (i = ROIi1;i < ROIi2; i++) { for (j = ROIj2; j > ROIj1; j--) { pixel = cvGet2D(img2, i, j); if((pixel.val[0])>=0.5) { // Si se encuentra una coincidencia ... encontrado=1; y= j+obj->width/2; x= i+obj->height/2; s=cvGet2D(color_dst,x,y); if(s.val[1]<100 ) {


18

// Pintamos en color_dst en el centro del posible cuadrado cvFloodFill(color_dst, cvPoint(y,x),cvScalar(85,0,0,0),cvScalarAll(0),cvScalarAll(0), NULL,4,NULL ); // cambiamos el color del pixel cvSet2D(color_dst,x,y,cvScalar(0,100,0,0)); } //se hace un rectangulo en el campo cvRectangle(campo, cvPoint(j,i), cvPoint(j+obj->width-1,i+obj->height-1), cvScalar(255,0,0,0), 1 ,8,0); // se dibuja una cruz en el campo for (k=-5;k<6;k++) cvSet2D(campo,x+k,y,cvScalar(0,0,255,0)); for (k=-5;k<6;k++) cvSet2D(campo,x,y+k,cvScalar(0,0,255,0)); } } } cvShowImage("Lineas",color_dst); cvShowImage("Campo",campo); cvWaitKey(1); printf("\n presione una tecla para continuar\n"); cvWaitKey(1); getch (); // ahora se contaran los cuadrados encontrados y se locarizara su centro // para ello se aprovecha la acumulacion de pixeles del mismo color cantidadcuadrados=0; for (i=0;i<color_dst->height;i++) for (j=0;j<color_dst->width;j++) { color=((uchar *)(color_dst->imageData + i*color_dst->widthStep))[j*color_dst->nChannels +1]; //se busca un color especifico en color_dst if(color==100) { //se cambia el color del area a un azul oscuro cvFloodFill(color_dst, cvPoint(j,i),cvScalar(100,0,0,0),cvScalarAll(0),cvScalarAll(0), NULL,4,NULL ); cvShowImage("Lineas",color_dst); cvWaitKey(1);


19

//se promedian la posicion de todos los pixeles de color azul oscuro isum=0; jsum=0; cantidad=0; for (ii=0;ii<color_dst->height;ii++) for (jj=0;jj<color_dst->width;jj++) { color=((uchar *)(color_dst->imageData + ii*color_dst->widthStep))[jj*color_dst->nChannels +0]; if(color==100) { isum=isum+ii; jsum=jsum+jj; cantidad=cantidad+1; } } // se obtiene la posicion final del centro del cuadrado cuadrados[cantidadcuadrados].i=isum/cantidad; cuadrados[cantidadcuadrados].j=jsum/cantidad; cantidadcuadrados=cantidadcuadrados+1; // Se cambia el color a un azul mas claro cvFloodFill(color_dst, cvPoint(j,i),cvScalar(255,0,0,0),cvScalarAll(0),cvScalarAll(0), NULL,4,NULL ); cvShowImage("Lineas",color_dst); cvWaitKey(1); } } cvShowImage("Lineas",color_dst); cvWaitKey(1); printf("\n presione una tecla para continuar...\n"); getch(); printf("Cantidad encontrados: [%d]\n",cantidadcuadrados); jcomp=0; icomp=0; // Se vuelve a cargar la imagen original campo= cvLoadImage(direccioncampo,4); for (i=0;i<cantidadcuadrados;i++) { // se hace una cruz for (k=-5;k<6;k++)


20

cvSet2D(color_dst,cuadrados[i].i+k,cuadrados[i].j,cvScalar(0,0,255,0)); for (k=-5;k<6;k++) cvSet2D(color_dst,cuadrados[i].i,cuadrados[i].j+k,cvScalar(0,0,255,0)); // se hace un rectangulo en el campo por cada cuadrado encontrado cvRectangle(campo, cvPoint(cuadrados[i].j-(obj->width)/2,cuadrados[i].i-(obj->width)/2), cvPoint(cuadrados[i].j+(obj->width)/2,cuadrados[i].i+(obj->width)/2), cvScalar(0,255,0,0), 2 ,8,0); //buscando el de la derecha.. if(cuadrados[i].j>jcomp) { jcomp=cuadrados[i].j; icomp=cuadrados[i].i; } } printf("\n Agregando flecha...\n"); // Se agregan lineas para hacer una flecha cvCircle(campo, cvPoint(jcomp,icomp), 15, cvScalar(100,255,200,0), 8,5,0); cvLine(campo, cvPoint(jcomp,campo->height-200), cvPoint(jcomp+20,campo->height-180), cvScalar(100,255,200,0), 5,8,0); cvLine(campo, cvPoint(jcomp-20,campo->height-180), cvPoint(jcomp,campo->height-200), cvScalar(100,255,200,0), 5,8,0); cvLine(campo, cvPoint(jcomp,campo->height-1), cvPoint(jcomp,campo->height-200), cvScalar(100,255,200,0), 5,8,0); // Se agrega texto cvInitFont( &font, CV_FONT_HERSHEY_SIMPLEX | CV_FONT_ITALIC,1, 1, 0, 2,5 ); cvPutText(campo, "Empujar siguiente", cvPoint(100,campo->height-150), &font, cvScalar(100,255,200,0) ); cvShowImage("Campo",campo); cvWaitKey(1); printf("La posicion del de la derecha es (i,j):[%d,%d]\n",icomp,jcomp); cvCircle(color_dst, cvPoint(jcomp,icomp), 15, cvScalar(0,255,255,0), 8,5,0); cvShowImage("Lineas",color_dst); cvWaitKey(1); printf("\n presione una tecla para continuar\n"); getch();


21

printf("************************************\n"); printf("************************************\n"); printf("Presione una tecla para finalizar\n"); cvWaitKey(1); getch(); //cierra las ventanas abiertas cvDestroyWindow("Campo"); cvDestroyWindow("Objetivo"); cvDestroyWindow("Lineas"); // Libera la memoria cvReleaseImage(&campo); cvReleaseImage(&obj); cvReleaseImage(&img2); cvReleaseImage(&blancyneg); cvReleaseImage(&color_dst); cvReleaseImage(&bordes); cvWaitKey(1); return(EXIT_SUCCESS); }


22

ANEXO

Instalación de la librería: En esta práctica se utilizó la programación en C. Una de las ventajas de C es que es un lenguaje muy utilizado en muchos sistemas operativos y también en microcontroladores. Por lo que resulta interesante. Se usaron las funciones de OpenCV. Las cabeceras usadas son cv.h y higui.h. Particularmente usamos la versión 2.4.3 La descarga de estas librerías es gratuita y puede hacerse desde la página oficial opencv.org. La descarga ofrece un paquete para armar librerías según el procesador y el sistema operativo. Sirven tanto para programación en C, en C++ y otros. Armarse una librería en forma ortodoxa puede ser un poco tedioso, lleva tiempo y hay que descargarse programas auxiliares siguiendo un instructivo. Nosotros ya que solo utilizaremos las librerías básicas simplemente indicamos la librería de la siguiente manera. Vamos a la carpeta donde descomprimimos el paquete de OpenCV. Vamos a …\opencv\build Nota: los puntos suspensivos son porque el usuario puede descargar las carpetas en cualquier unidad o carpeta que desee. HEADERS Allí encontraremos los headers en la carpeta include: Este es el path que tendremos que agregar al compilador …\opencv\build\include Las cabeceras antiguas están en la carpeta opencv y las nuevas cabeceras están en opencv2 En rigor de verdad las cabeceras antiguas están todas en opencv2 pero para mantener la antigua estructura en opencv se mantienen los nombres antiguos y se vinculan con las de opencv2. En opencv2 las cabeceras se han ordenado en varias carpetas y se dividen según el propósito: estructuras básicas, utilización de cámara, detección de objetos, manipulación de imágenes(filtros),etc. La nueva tendencia es focalizar las librerías según la utilidad, probablemente debido tambien a la creación de cada vez mas funciones.


23

Para indicar el path(directorio) de los headers lo haremos hasta la carpeta include. De modo que si queremos usar las librerías cv.h y higui.h lo indicaremos agregando en el programa así: # include<opencv/cv.h> # include<opencv/higui.h> O sea incluimos la carpeta “opencv” LIB Los headers necesitan de las librerías para funcionar. Utilizaremos las de x86 ya que ese es el procesador con el que trabajaremos El path de los LIBs que tendremos que indicarle al compilador es …\opencv\build\x86\vc10\lib En el compilador tendremos que indicar las librerías que utilizaremos. A continuación están todas las que tiene OpenCV 2.4.3 -lopencv_calib3d243d -lopencv_contrib243d -lopencv_core243d -lopencv_features2d243d -lopencv_flann243d -lopencv_gpu243d -lopencv_highgui243d -lopencv_imgproc243d -lopencv_legacy243d -lopencv_nonfree243d -lopencv_objdetect243d -lopencv_photo243d -lopencv_stitching243d -lopencv_ts243d -lopencv_video243d -lopencv_videostab243d -lopencv_ml243d Las que utilizamos en el programa son específicamente: -lopencv_imgproc243d -lopencv_highgui243d -lopencv_core243d Con esto le indicamos al compilador que busque en el path previamente indicado a las funciones de OpenCV dentro de estas librerías. opencv_imgproc243d.lib opencv_highgui243d.lib opencv_core243d.lib el path es justamente “…\opencv\build\x86\vc10\lib” BIN (DLL) Tambien necesitaremos de las librerías dinámicas (dll) para que nuestro programa funcione. Tenemos varias opciones.

Agregar el path al sistema operativo, Windows. Existen aplicaciones para hacerlo. Copiar y pegar los DLL en un path del sistema por ejemplo en la carpeta

c:\Windows\system32\ Copiar y Pegar los DLL que utilizaremos en la carpeta donde se ejecutará el programa

pero se perdería el sentido de librería dinámica aunque sería mas transportable ya que estos dll son poco comunes.


24

Los dll se encuentran en el path “…\opencv\build\x86\vc10\bin” Nosotros usaremos solo los siguientes dll: opencv_imgproc243.dll opencv_core243.dll opencv_highgui.dll Tambien tuvimos que descargar desde internet estos dos dll msvcp100d.dll msvcr100d.dll ya que estos últimos no se encontraban en nuestro sistema operativo. Sin estos dll en seguida el programa nos los pedirá al intentar ejecutarse. Los dll son “pesados”(ocupan lugar en disco) en comparación con el programa en sí, así que si usamos varios programas basados en OpenCV es conveniente tenerlos ya en el sistema operativo.

El Compilador: Podemos usar varios programas para desarrollar programas en OpenCV. Las nuevas versiones de OpenCV recomiendan usar el Visual Studio 10. Es muy poderoso pero este requiere de licencias y además es pesado a la hora de ejecutarlo(utiliza muchos recursos del procesador). Como nuestro programa es un programa simple en C vamos a usar el software gratuito Dev C++ Lo mas importante es que pudimos encontrar mucha documentación sobre trabajos de Open CV desarrollados en esta plataforma. Preparando el compilador: Debemos “enseñarle” al compilador a usar las librerías OpenCV Para ello vamos al menú “Herramientas” y seleccionamos “Opciones del compilador”


25

Allí agregamos un nuevo compilador y le ponemos un nombre por ejemplo: “OpenCV2.4.3”

Le indicamos el path de las librerías, ¿Dónde las encontrará? El path (directorio donde buscará los recursos) es donde se haya descargado el OpenCV eso es criterio del usuario. Nos vamos a la pestaña Directorios, A Bibliotecas, Señalamos donde se encuetran los libs y Añadimos.


26

Ahora agregaremos el path de los headers. Solo agregaremos los de C porque trabajaremos solo en ese lenguaje. Nos vamos a la pestaña “Includes C” agregamos el path donde está el include…

Añadimos los comandos al llamar al compilador: en este caso solo los 3 que utilizaremos pero podemos agregar todos los del openCV así ya nos queda listo para todas las funcionalidades.


27

Listo con eso ya se puede compilar el programa.

Nota: Hemos notado que algunas funciones han aumentado la cantidad de parámetros que utilizan en las nuevas versiones. Por ejemplo: cvScalar() requería solo de 3 parametros, ahora requiere de 4. Por eso a la hora de compilar códigos antiguos deberán corregirse primero estos detalles.

Funciones de OpenCV utilizadas: char cvWaitKey(int milisegundos) Lee una tecla del teclado durante los milisegundos indicados como parametro y devuelve el carácter. Si se pone cero como parámetro de milisegundo, queda esperando hasta que se apriete una tecla. Es necesario que el usuario esté focalizado en alguna ventana del programa. Es necesario llamar esta función cada tanto para refrescar las imágenes cvSet2D(IplImage * img,int x,int y,CvScalar Color); Cambia los valores de un pixel de la imagen en la posición x,y


28

cvRectangle(IplImage * img, CvPoint esquinaInicial, CvPoint esquinaOpuesta,CvScalar Color, int espesor, int tipo , int desplazamiento); Dibuja un rectángulo cvCircle(CvArr* img, CvPoint center, int radius, CvScalar color, int thickness=1, int line_type=8, int shift=0 ) Dibuja un círculo. cvLine(CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color, int thickness=1, int line_type=8, int shift=0 ) Dibuja una línea. cvInitFont(CvFont* font, int font_face, double hscale, double vscale, double shear=0, int thickness=1, int line_type=8 ) Inicializa una fuente de texto. cvPutText(CvArr* img, const char* text, CvPoint org, const CvFont* font, CvScalar color) Escribe en una imagen. IplImage* cvCreateImage(CvSize dimenciones, int depth, int canales); Crea una imagen del tipo IplImage, según las dimensiones, depth y canales. Los canales indican la cantidad de colores de la imagen. void cvMatchTemplate(const CvArr* imagen, const CvArr* plantilla, CvArr* resultado, int metodo) Crea una imagen resultado donde la intensidad de los pixeles depende de la probabilidad de que en esa posición la plantilla patrón coincida con la imagen fuente. CvScalar cvGet2D(const CvArr* imagen, int x, int y) Devuelve los valores de un pixel de la imagen en la posición x, y void cvResize(const CvArr* src, CvArr* dst, int interpolation=CV_INTER_LINEAR ) Redimenciona la imagen fuente src y lo guarda en una imagen destino dst. Dependiendo el método. El método por default es CV_INTER_LINEAR es decir trata de ajustar la imagen fuente al tamaño que tiene la imagen destino. void cvCopy(const CvArr* src, CvArr* dst, const CvArr* mask=NULL) Copia la imagen fuente en la imagen destino. Opcionalmente se puede agregar una máscara. IplImage* cvLoadImage(const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR ) Abre una imagen indicada por filename, con el método de color. Se puede abrir por ejemplo en blanco y negro. void cvReleaseImage (IplImage** image) Cierra y libera de la memoria una imagen int cvNamedWindow(const char* name, int flags=CV_WINDOW_AUTOSIZE ) Crea una ventana con el nombre indicado por name.


29

void cvDestroyWindow(const char* name) Destruye una ventana específica cvShowImage(const char* name, const CvArr* image) Muestra la imagen en la ventana indicada cvSet(CvArr* arr, CvScalar value, const CvArr* mask=NULL) Setea todos los pixeles de una imagen cvCanny(const CvArr* image, CvArr* edges, double threshold1, double threshold2, int

aperture_size=3 ) Saca los contornos de una imagen cvFindContours(CvArr* image, CvMemStorage* storage, CvSeq** first_contour, int header_size=sizeof(CvContour), int mode=CV_RETR_LIST, int method=CV_CHAIN_APPROX_SIMPLE, CvPoint offset=cvPoint(0,0) ) Extrae los contornos encontrados con la función cvCanny cvDrawContours(CvArr* img, CvSeq* contour, CvScalar external_color, CvScalar hole_color, int max_level, int thickness=1, int line_type=8, CvPoint offset=cvPoint(0,0) ) Dibuja los contornos extraidos por cvFindContours cvFloodFill(CvArr* image, CvPoint seed_point, CvScalar new_val, CvScalar lo_diff=cvScalarAll(0), CvScalar up_diff=cvScalarAll(0), CvConnectedComp* comp=NULL, int flags=4, CvArr* mask=NULL ) Pinta un pixel y todos los pixeles del mismo color alrededor.

universidad tecnologica nacional facultad regional … de palanquillas … · utilizar librería de...

Documents