Download - 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.
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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”
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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.
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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.
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
3. En el administrador de propiedades del proyecto agregamos una nueva hoja de
propiedades con nombre DEBUG
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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.
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
5. Adicionamos las librerías
opencv_ts300d.lib
opencv_world300d.lib
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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/
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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.
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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.
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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.
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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);
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
*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;
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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;
Visión Artificial, Instituto Tecnológico Metropolitano Carlos A. Madrigal
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;