Introducción_OpenCV

Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal

INTRODUCCIÓN A OPENCV

Que es OpenCV?

OpenCV (Open Source Computer Vision Library) son unas librerías de código abierto para

visión por computador y aprendizaje automático. La librería está escrita en C y C++

optimizado y corre bajo Linux, Windows, Mac OS X, Android y iOS. Fue diseñado para

crear aplicaciones eficientes en tiempo real.

OpenCV tiene una estructura modular compuesta por diferentes librerías estáticas o

compartidas.

Core: Maneja las estructuras básicas que son necesarias para todos los módulos,

incluyendo la matriz MAT.

Imgproc: Modulo de procesamiento de Imágenes. Incluye filtrado, transformaciones

geométricas, histograma, conversión de color.

Video: Maneja los algoritmos de análisis de video, detección de movimiento, sustracción

de fondo, seguimiento de objetos.

calib3d: Maneja los métodos para calibración, correspondencia y reconstrucción 3D.

features2d: Incluye algoritmos de descripción y comparación de características.

Objdetect: Incluye algoritmos para aplicaciones específicas de detección como: rostros,

ojos, carros).

Highgui: Es el módulo de interface para la captura y visualización de imágenes y video.

Gpu: Maneja algunos algoritmos de otros módulos mediante aceleramiento-GPU,

Flann: (Fast Library for Approximate Nearest Neighbors) es una librería que contiene una

serie de algoritmos optimizados para la búsqueda de los vecinos más cercanos de manera

rápida.

OCL: Contiene un conjunto de clases y funciones que implementan y aceleran las

funcionalidades de OpenCV sobre dispositivos compatibles con OpenCL.


Aplicaciones Realizadas con OpenCV

Son una de las librerías de mayor uso para productos comerciales de computer visión.

Tiene más de 2500 algoritmos optimizados, los cuales pueden ser usados reconocimiento

de rostros, identificación de objetos, clasificación de acciones humanas en videos,

seguimiento de objetos y personas, extraer modelos 3D de objetos, producir nubes de

puntos 3D desde visión estéreo, integrar imágenes para producir otras de mayor

resolución. Han sido usadas para el proyecto de vista panorámica de calles de Google, el

sistema de visón del robot PR2 de Willow Garage, los robots de exploración de marte de la

NASA, el control de calidad en la producción de monedas en China, entre otros.

Mi primer proyecto con OpenCV.

En este ejercicio se va a empezar con la aplicación más básica del procesamiento digital de

imágenes, Cargar una Imagen. Quizás todos los que creemos tener algún conocimiento en

el área de visión artificial comenzamos por aquí. Y no es gratuito, teniendo en cuenta que

el primer proceso dentro de un sistema de visión artificial es la adquisición de la señal o

imagen.

1. Para trabajar con las librerías de OpenCV debemos incluir algunas rutas dentro del

Visual Studio y en nuestro proyecto Ejercicio_1. Para esto se deben incluir las rutas

básicas de los archivos de inclusión necesarios para el uso de OpenCV. (Pueden

seguir los siguientes tutoriales https://www.youtube.com/watch?v=EcFtefHEEII

https://www.youtube.com/watch?v=tHX3MLzwF6Q). Si se va a trabajar con una

versión anterior de OpenCV se debe cambiar “OpenCV3.0” por la versión anterior

por ejemplo “OpenCV2.4.3”


I. Se extraen las carpetas de OpenCV en la ruta C:\OpenCV2.4.3

II. Configuramos las variables de entorno y las adicionamos al path del sistema.

Esto para facilitar la construcción y compilación de los programas con OpenCV

sin tener que repetir muchos de los pasos de inclusión.

Ingresamos con click derecho a Equipo->Propiedades->Configuración Avanzada del

Sistema->Variables de entorno.

Creamos una nueva variable de entorno llamada OPENCV_BUILD con dirección

C:\OpenCV3.0\build

En las variables del sistema adicionamos la ruta donde se encuentran las Dlls de OpenCV

en la variable PATH. %OPENCV_BUILD%\x86\vc10\bin\ Se debe cambiar x86 por x64

cuando estamos trabajando con un sistema operativo de 64bits.


2. Creamos en Visual Studio C++ 2010 o 2012 un nuevo proyecto del tipo Aplicación

de Consola Win32 y lo nombramos Ejercicio_1.

En la configuración de la aplicación escogemos proyecto vacío y sin la opción encabezado

precompilado como muestra la figura.


3. En el administrador de propiedades del proyecto agregamos una nueva hoja de

propiedades con nombre DEBUG


4. Dando click derecho sobre DEBUG ingresamos a la ventana de propiedades, donde

se adicionan las rutas de los archivos de inclusión y de librerias.


5. Adicionamos las librerías

opencv_ts300d.lib

opencv_world300d.lib


6. Los pasos 3,4 y 5 también deben hacerse para la carpeta Release|Win32

7. Adicionamos un nuevo archivo de código fuente donde ira nuestro programa y lo

nombramos main.cpp


8. Pegamos o escribimos el siguiente código en el archivo main.cpp

Ejercicio #1.

#include <opencv2\opencv.hpp> using namespace cv; int main(){

1. Mat imagen;

2. namedWindow("window",1);

3. imagen= imread("c:\\lena.jpg");

4. imshow("window",imagen);

5. waitKey(10000);

6. getchar();

7. return 0; }

1 se crea una estructura llamada imagen del tipo Mat.

En 2 se crea una ventana llamada “window”.

En 3 imread es una estructura que reserva automaticamente el espacio de memoria

necesario para albergar la imagen ubicada en la direccion mostrada por el argumento.

Esta función puede cargar diferentes formatos de imágenes como BMP, DIB, JPEG, JPE,

JPG, JP2, PNG, PBM, PGM, PPM, SR, RAS, TIFF, TIF.

Entre otras Cosas: la figura que se carga en este ejercicio,

es la imagen más famosa y utilizada por la comunidad en visión

computacional, especialmente en investigaciones de compresión de

imágenes. Lena Soderberg es el nombre de una mujer sueca que en

1972 poso para la revista Playboy. Según David Munson jefe de

discuciones en el área de tratamiento de imágenes de la IEEE en

1996. Hay 2 razones que explican la popularidad de esta imagen.

1. "Esta imagen contiene buenas mezclas de detalles, de

zonas planas, y una textura que hace trabajar bien a los

diferentes algoritmos de compresión de imagen. ¡Es una

buena imagen de prueba!

2. Además, "Lena" es la imagen de una mujer atractiva.

Se puede encontrar más información en http://ndevilla.free.fr/lena/


En 4 imshow permite visualizar la imagen guardada en la estructura imagen sobre la

ventana “window”.

En 5 se espera 10seg para manipular la ventana de imagen.

En 6 se espera que se presione una tecla para cerrar la ventana.

En 7 se retorna un entero de la función main para salir.


9. Si le aparece esta ventana de error.

Pegue los siguientes dll´s en la carpeta C:\Windows\System

msvcp100d.dll

msvcr100d.dll

Representación y estructura de una imagen en Opencv.

Mat es la estructura que más frecuentemente se usa en OpenCV para representar una

imagen, ya sea en escala de grises, a color o RGBa.

Algunas de las propiedades más importantes de Mat son:

int dims; // La dimensionalidad de la matriz

int rows, cols; // El número de filas y columnas

uchar* data; // un apuntador tipo uchar a los datos de la imagen.

Manipulación de Pixeles con OpenCv

Hay diferentes formas de acceder directamente al valor de un pixel en OpenCV, sin

embargo, solo hay una manera eficiente y adecuada para realizarlo, y es utilizando

apuntadores, lo único que hay que saber es que la imagen se guarda en una secuencia de

datos como muestra la figura.


Forma 1 de Accesar los Datos en una Imagen. image.at<uchar>(j,i)= 255;

at<>(int y, int x) Es uno de los métodos de la estructura Mat para accesar los datos

de una imagen de un canal, para esto es necesario conocer el tipo de dato a accesar

(uchar, int, float) y la posición del pixel en la imagen.

Para imágenes de color con 3 componentes (ej: RGB), se utilizaría de la siguiente manera.

image.at<cv::Vec3b>(j,i)[channel]= value;

Donde channel es la componente de color a accesar.

Forma 2 de Accesar los Datos en una Imagen. cv::Mat_<uchar> im2= image; im2(j,i)= 255;

Recorrer completamente una Imagen.


Supongamos que deseamos cargar una imagen e intercambiar las componentes de color

azul y rojo, para hacer este recorrido completo de la imagen es posible hacerlo de

diferentes maneras unas más eficientes que otras, y teniendo en cuenta que muchas

aplicaciones de la visión artificial son en tiempo real, es necesario desarrollar código

eficiente para lograr tiempos de procesamiento pequeños.

Forma 1.

for (int j=0; j<imagen.rows; j++) { uchar* data= imagen.ptr<uchar>(j); for (int i=0; i<imagen.cols; i++) { uchar valor= data[3*i]; data[3*i]=data[3*i+2]; data[3*i+2]=valor; } }

image.ptr<uchar>(j); Es un método de la clase Mat que retorna la dirección de

memoria del primer pixel de la fila j.

Forma 2. Una de las más eficientes es la mostrada a continuación.

int nl= imagen.rows;

int nc= imagen.cols ; if (imagen.isContinuous()) { nc= nc*nl; nl= 1; } for (int j=0; j<nl; j++) { uchar* data= imagen.ptr<uchar>(j); for (int i=0; i<nc; i++) { uchar valor= *data; *data++= *(data+2);


*data++; *data++=valor; } }

Ejercicio #2. En este ejercicio se desea partir la imagen en 4 cuadrantes y mostrar la contribución de las

componentes de color R, G, y B a la formación de la imagen, el resultado es guardado en

otra imagen.

Tiempo de Ejecución= 0.6ms

Mat imagen, imagenResultado;


namedWindow("window",1); namedWindow("window1",1); imagen= imread("c:\\lena.jpg"); imagenResultado.create(imagen.rows,imagen.cols,CV_8UC3); int mf= imagen.rows/2; //Mitad de las Filas int mc=imagen.cols/2; //Mitad de las Columnas double duration; duration = static_cast<double>(cv::getTickCount()); for (int j=0; j<mf; j++) { uchar* data= imagen.ptr<uchar>(j); uchar* data1= imagenResultado.ptr<uchar>(j); for (int i=0; i<mc; i++) { data1[3*i]=data[3*i]; data1[3*i+1]=data[3*i+1]; data1[3*i+2]=data[3*i+2]; } } for (int j=0; j<mf; j++) { uchar* data= imagen.ptr<uchar>(j); uchar* data1= imagenResultado.ptr<uchar>(j); for (int i=mc; i<imagen.cols; i++) { data1[3*i]=0; data1[3*i+1]=0; data1[3*i+2]=data[3*i+2]; } } for (int j=mf; j<imagen.rows; j++) { uchar* data= imagen.ptr<uchar>(j); uchar* data1= imagenResultado.ptr<uchar>(j); for (int i=0; i<mc; i++) { data1[3*i]=0;


data1[3*i+1]=data[3*i+1]; data1[3*i+2]=0; } } for (int j=mf; j<imagen.rows; j++) { uchar* data= imagen.ptr<uchar>(j); uchar* data1= imagenResultado.ptr<uchar>(j); for (int i=mc; i<imagen.cols; i++) { data1[3*i]=data[3*i]; data1[3*i+1]=0; data1[3*i+2]=0; } } duration = static_cast<double>(cv::getTickCount())-duration; duration /= cv::getTickFrequency(); // the elapsed time in ms imshow("window",imagen); imshow("window1",imagenResultado); waitKey(10000); printf("duración: %f", duration); getchar(); return 0;

Introducción_OpenCV

Documents

Transcript of Introducción_OpenCV