OpenCV PDF

Universidad Politécnica de
Tulancingo
Programación en C++ usando la biblioteca

de OpenCV
por
Martin Enrique Martínez Hernández
Reporte de Estadía
en el
Laboratorio de Óptica y Sistemas de Visión por
Computadora
Asesora
Dra. Carina Toxqui Quitl
Universidad Politécnica de Tulancingo
2
Resumen
En este reporte de estadía se analizan e implementan las funciones más

comunes del procesamiento digital de imágenes usando la biblioteca de OpenCV.
Los algoritmos presentados son desarrollados en Visual Studio 2010.
Se abordan tres problemas en el contexto de Visión por Computadora. El control

de calidad de botellas PET, la segmentación de imágenes y la detención de
bordes para el análisis del lenguaje a señas.
3
4
Índice general
1. Introducción ……………………………………………………………………………………..……..7
2. Estructura de OpenCV ……………………………………………………………………..……..11
2.1 Procesamiento de imágenes y algoritmos de visión …………………..……….12
2.1.1 Binarización……………………………………………………………………………12
2.1.2 Trasformación gamma…………………………………………………………….16
2.1.3 Histograma y Ecualización del Histograma ................. ...................18
2.1.4 Laplaciano ………………………………………………………………….………….21
2.2 Estructura y Algoritmos………………………………………………………...……………23
2.2.1 Dilatación y Erosión ……………..………………………………………………….23
2.2.2 Canny ……………………………………………………………………………………..25
3. Sistema de Visión por Computadora …………………………………………………………27
3.1 Control de calidad ……………………………………………………………………………..30
3.2 Análisis de la marcha …………………………………………………………………………33
3.3 Lenguaje a Señas ..…………………………………………………………………………….36
4. Conclusiones …………………………………………………………………………………………..39
5. Apéndice - CUDA ………………………………………………………………………………………41
6. Referencias ……………………………………………………………………………………………..43
5
6
Capítulo 1
Introducción
Se llevó a cabo la búsqueda de una nueva herramienta de visión por computadora que
permita procesar información en tiempo real. Para esto se escogió la biblioteca de
OpenCV. Es una biblioteca que cuenta con mas de 500 funciones las cuales están
enfocadas a visión por computadora y están basadas en un lenguaje de programación
como es “C” y “C++” y es muy familiar para cualquier desarrollador del área de
Sistemas Computacionales.
OpenCV permite procesar imágenes en tiempo real y es muy sencillo hacer interactuar
con la cámara y la biblioteca ya que es una de sus características, la desventaja que
podremos encontrar es que al trabajar video el procesamiento de la CPU es muy
tardado. Para ello necesitaríamos utilizar la GPU con la ayuda de la interfaz de CUDA
mediante la programación en paralelo para poder combinar la CPU con la GPU.
Problema
En los procesos de Visión por Computadora se requiere de un análisis y procesamiento

de series de imágenes en tiempo real. Lo cual no ha sido logrado debido a que el
procesado en CPU que actualmente se realiza es muy tardado.
Propuesta
Utilizar la biblioteca de OpenCV ya que contiene más de 500 funciones para el área de
visión por computadora en tiempo real, procesando imágenes digitales y reduciendo
costos de tiempo en la ejecución en su procesamiento.
7
Objetivo
Dar a conocer algunas de las funciones que brinda OpenCV para poder tener una
herramienta de procesamiento en tiempo real que va a permitir reducción de tiempos
en procesamiento.
OpenCV
Es una librería de tratamiento de imágenes, destinada principalmente a aplicaciones

de visión por computadora en tiempo real.
Son un conjunto de bibliotecas de C y C++ de código libre, orientadas a visión por

computadora.
Puede ser usado en Windows, Linux y MacOS
8
9
¿Por qué OpenCV?
 Contienen herramientas para la interpretación de la imagen.
 Contiene una variedad de ejemplos que ayudan a comprender su

funcionamiento además de que en la red existen grupos de ayuda
especializada.
 Es una librería que funciona para C/C++, por ser una librería completa en
funciones para realizar operaciones sobre imágenes.
 Es una biblioteca gratuita.
 Realiza análisis de movimiento y seguimiento de objetos.
 La biblioteca esta en constante actualización al inicio de mi investigación

estaba la versión 2.2 y ya cuenta con la versión 2.4.
 Para procesar video en OpenCV es muy tardado para ellos se necesitaría de

ayuda de la GPU.
¿Qué podemos hacer con OpenCV?
OpenCV nos permite entre muchas otras cosas:
• Operaciones básicas, como (suma, productos, integraciones, derivaciones, etc.)
• Procesado de imágenes y análisis,
• Análisis estructural,
• Análisis de movimiento,
• Reconstrucción 3d y calibración de la cámara,
• Interfaz gráfica y adquisición,
Su licencia de OpenCV
Intel fue el pionero en el desarrollo de OpenCV, sin embargo su licencia permite el
desarrollo con las bibliotecas e inclusive la modificación y distribución de las mismas,
también la explotación, investigación y comercialización.
10
Capítulo 2
Estructura de OpenCV
Introducción
En este capitulo se describe la librería de OpenCV para el análisis y

procesamiento de imágenes.
Se proporciona el código de algunas tareas básicas para el mejoramiento y realce en

imágenes.
Estas bibliotecas se dividen en cuatro grandes grupos:
1. CXCORE: Donde se encuentran las estructuras y algoritmos básicos que

usan las demás funciones. Ejemplo: suma, media. Operaciones-
binarias. etc.
2. CV: donde están implementadas las funciones principales de

procesamiento de imágenes. Ejemplo: Erosión, Dilatación, Operaciones
básicas de umbralización, Derivados de Sobel, Operador de Laplace, etc.
3. HighGUI: todo lo relacionado a la interfaz gráfica de OpenCV y las

funciones que permiten importar imágenes y video.
11
4. ML: que cuenta con algoritmos de aprendizaje, clasificadores.
En esta investigación de las cuatro grupos con los que cuenta OpenCV solo se
utilizaron: “CV, HighGUI, CXCORE”.
12
2. 1 Procesamiento de Imágenes y Algoritmos de visión.
El objetivo de procesamiento de imágenes es mejorar la calidad de las

imágenes para su posterior utilización o interpretación. Para ello OpenCV cuenta con
unas gran Biblioteca con más 500 funciones las cuales están diseñadas para
Algoritmos de visión por computadora.
2.1.1 Binarización
Esta operación transforma la imagen a solo dos colores blanco y negro. El proceso
para binarizar la imagen es el siguiente:
1. Se encuentra la mediana (dato de en medio) de los valores permitidos para

cada píxel.
2. Se toma uno por uno los píxeles de la imagen.
3. Se compara cada píxel: si el valor del píxel es menor a la mediana entonces ese
píxel toma el valor mínimo permitido, caso contrario toma el valor máximo
permitido.
13
Código desarrollado en Visual Studio 2010 con la biblioteca de OpenCV para la
Binarización de imágenes.
#include "cv.h"
#include "highgui.h"
#include "math.h"
int main()
{
IplImage* src; // imagen de color base
IplImage* colorThresh; // contendrá la imagen de color binarizada
IplImage* gray; // contendrá la imagen convertida en escala de grises
IplImage* grayThresh; // imagen binaria conseguida a partir de la imagen en
escala de grises
int threshold = 120; // definimos el valor umbral

int maxValue = 255; // definimos el valor máximo
int thresholdType = CV_THRESH_BINARY; // definimos el tipo de binarización
src = cvLoadImage("lena.bmp", 1); // cargamos imagen de color

colorThresh = cvCloneImage( src ); // copiamos esa imagen de color
gray=cvCreateImage( cvSize(src->width, src->height), IPL_DEPTH_8U, 1 );
// la imagen de intensidad tendrá la misma configuración
// que la fuente pero con un solo canal
cvCvtColor( src, gray, CV_BGR2GRAY ); // pasamos la imagen de color a escala
de grises
grayThresh = cvCloneImage( gray ); // copiamos la imagen en escala
// de grises (truco anterior)
cvNamedWindow( "src", 1 ); // representamos la imagen de color
cvShowImage( "src", src );
cvNamedWindow( "gray", 1 ); // representamos la imagen de intensidad
cvShowImage( "gray", gray );
cvThreshold(src, colorThresh, threshold, maxValue, thresholdType);
// binarizamos la imagen de color
cvThreshold(gray, grayThresh, threshold, maxValue, thresholdType);
// binarizamos la imagen de intensidad
cvNamedWindow( "colorThresh", 1 ); // representamos la imagen
// de color binarizada
cvShowImage( "colorThresh", colorThresh );
cvNamedWindow( "grayThresh", 1 ); // representamosla imagen
// de intensidad binarizada
cvSaveImage("lena1.bmp", gray); // guardamos la imagen

cvSaveImage("lena2.bmp", grayThresh); // guardamos la imagen
cvShowImage( "grayThresh", grayThresh );
cvWaitKey(0); // pulsamos tecla para terminar
cvDestroyWindow( "src" ); // destruimos todas las ventanas
cvDestroyWindow( "colorThresh" );
cvDestroyWindow( "gray" );
cvDestroyWindow( "grayThresh" );
cvReleaseImage( &src ); // eliminamos todas las imágenes
cvReleaseImage( &colorThresh );
cvReleaseImage( &gray );
cvReleaseImage( &grayThresh );
//getch (1);
return 0;
}
14
Resultados:
Imagen escala a grises Imagen Binarizada con

umbral = 120
15
2.1.2 Transformaciones en intensidad
Contraste
El contraste es la relación entre las intensidades de los pixeles en una imagen,

también se puede definir como la relación entre la iluminación máxima y mínima de un
objeto.
BRILLO
El brillo es la luz que refleja o emite un cuerpo. La forma de aumentar o disminuir el

brillo es incrementando o disminuyendo el valor de los píxeles de cada canal.
Aumento de Brillo.
En esta operación se aumenta la intensidad en una imagen. Esta operación la realizo

en combinación de varias funciones, no existe una función que por si sola haga la
operación.
Código desarrollado en Visual Studio 2010 con la biblioteca de OpenCV para el

mejoramiento del contraste en una imagen.
#include <cv.h>
#include <highgui.h>
#include <iostream>
using namespace cv;
double alpha; /**< Control de contraste simple */

int beta; /**< Control de brillo simple */
int main( int argc, char** argv )

{
/// Leer la imagen dada por el usuario
Mat image = imread( "lena.bmp",1 );
Mat new_image = Mat::zeros( image.size(), image.type() );
/// Inicializar los valores

std::cout<<" contraste y brillo "<<std::endl;
std::cout<<"-------------------------"<<std::endl;
std::cout<<"* contraste [0-20]: ";std::cin>>alpha;
std::cout<<"* brillo [0-100]: "; std::cin>>beta;
/// operaciones
16
for( int y = 0; y < image.rows; y++ )
{ for( int x = 0; x < image.cols; x++ )
{ for( int c = 0; c < 3; c++ )
{
new_image.at<Vec3b>(y,x)[c] =
saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
}
}
}
/// crea la ventana

namedWindow("Imagen Original", 1);
namedWindow("Imagen Nueva", 1);
/// muestra las imagenes

imshow("Imagen Original", image);
imshow("Imagen Nueva", new_image);
/// Esperar hasta que el usuario pulsa alguna tecla

waitKey();
return 0;
}
Resultado:
Imagen Original Imagen con cambio en contraste = 2

y brillo =50
La aplicación pide que introduzcas un valor de contraste de 0 a 20 y un brillo de 0 a

100 para poder dar una imagen resultante.
17
2.1.3 Histograma y Ecualización del Histograma
Histograma.
El histograma es una gráfica que relaciona los niveles de intensidad de una imagen y
el número de píxeles que poseen tal nivel de intensidad.
Código desarrollado en Visual Studio 2010 con la biblioteca de OpenCV para el calculo
del histograma de una imagen.
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <iostream>
#include <stdio.h>
using namespace std;

using namespace cv;
/**
* @funcion main
*/
{
Mat src, dst;
/// cargar imagen

src = imread( "lena.bmp", 1 );
if( !src.data )
{ return -1; }
/// separa las imagenes en los 3 colores ( R,G,B )

vector<Mat> bgr_planes;
split( src, bgr_planes );
/// establecer el contador

int histSize = 256;
/// establecer rangos ( para B,G,R) )

float range[] = { 0, 256 } ;
const float* histRange = { range };
bool uniform = true; bool accumulate = false;
Mat b_hist, g_hist, r_hist;
/// calcular los histogramas:

calcHist( &bgr_planes[0], 1, 0, Mat(), b_hist, 1, &histSize, &histRange, uniform,
accumulate );
calcHist( &bgr_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange, uniform,
accumulate );
calcHist( &bgr_planes[2], 1, 0, Mat(), r_hist, 1, &histSize, &histRange, uniform,
accumulate );
18
// dibuja el histograma
int hist_w = 512; int hist_h = 400;
int bin_w = cvRound( (double) hist_w/histSize );
Mat histImage( hist_h, hist_w, CV_8UC3, Scalar( 0,0,0) );
/// Resulatdos
normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
/// dibuja para cada canal de RGB

for( int i = 1; i < histSize; i++ )
{
line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1))
),Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ), Scalar( 255, 0, 0), 2,
8, 0 );
line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) ,
Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),Scalar( 0, 255, 0), 2, 8,
0 );
line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) ,
Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),
Scalar( 0, 0, 255), 2, 8, 0 );
}
/// mostrar resultado

namedWindow("resultado histograma", CV_WINDOW_AUTOSIZE );
imshow("resultado histograma", histImage );
waitKey(0);
return 0;
}
Resultado:
Imagen original Histograma por canal rojo, verde y

azul (RGB).
19
Ecualización del histograma.
La ecualización del histograma se aplica cuando se desea lograr una distribución más
uniforme entre el número de píxeles referido a los diferentes niveles de intensidad
presentes en la imagen. Un histograma que se extienda en el intervalo de niveles de
gris.
Código desarrollado en Visual Studio 2010 con la biblioteca de OpenCV para la

ecualización del histograma.
#include <iostream>
#include <stdio.h>
using namespace cv;

using namespace std;
/** @funcion main */

{
Mat src, dst;
char* source_window = "imagen original";

char* equalized_window = "Equalized Image";
/// carga la imagen

src = imread( "lena.bmp", 1 );
if( !src.data )
{ cout<<"Usage: ./Histogram <path_to_image>"<<endl;
return -1;}
/// convierte a escala de grises

cvtColor( src, src, CV_BGR2GRAY );
/// áplicar la ecualizacion del histograma

equalizeHist( src, dst );
/// mostrar resultados

namedWindow( source_window, CV_WINDOW_AUTOSIZE );
namedWindow( equalized_window, CV_WINDOW_AUTOSIZE );
imshow( source_window, src );

imshow( equalized_window, dst );
/// guardar la imagen ecualizada
cvSaveImage("lenaecua.bmp", &IplImage(dst));
/// esperar asta cerrar la aplicacion
waitKey(0);
return 0;
20
}
Resultados:
Imagen Original Imagen resultante de la

ecualización de su histograma.
2.1.4 Laplaciano
Es un operador ideal para detectar bordes independientes de la orientación o dirección

de los mismos.
Código desarrollado en Visual Studio 2010 con la biblioteca de OpenCV para el

operador de Laplaciano.
#include <stdlib.h>
#include <stdio.h>
using namespace cv;

{
Mat src, src_gray, dst;
int kernel_size = 3;
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
char* window_name = "Laplace";
int c;
/// carga la imagen

src = imread( "lena.bmp",1 );
21
if( !src.data )
{ return -1; }
///Eliminar el ruido al difuminar con un filtro gaussiano

GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
/// convierte la imagen a escala de grises

cvtColor( src, src_gray, CV_RGB2GRAY );
///crea la ventana
namedWindow( window_name, CV_WINDOW_AUTOSIZE );
/// aplica la funcion la place

Mat abs_dst;
Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );

convertScaleAbs( dst, abs_dst );
/// guara la imagen

cvSaveImage("lenalaplace.bmp", &IplImage(dst));
/// mostrar el contenido

imshow( window_name, abs_dst );
waitKey(0);
return 0;
}
Resultado:
Imagen realzada usando el filtro

espacial Laplaciano.
22
2.2 Estructuras y Algoritmos
Las Estructuras y Algoritmos en OpenCV cuenta con una gran cantidad de funciones
que podemos encontrar como por ejemplo: suma, resta, multiplicación, media.
Operaciones- binarias. Dilatación, Erosión, Canny, etc.
2.2.1 Dilatación y Erosión
Dilatación
Este operador es comúnmente conocido como 'relleno', 'expansión' o 'crecimiento'.

Puede ser usado para rellenar 'huecos' de tamaño igual o menor que el elemento
estructurante con la que se opera la dilatación.
Erosión
Los efectos son de 'encogimiento', 'contracción', o 'reducción'. Puede ser utilizado para
eliminar islas menores en tamaño que el elemento estructural.
Código desarrollado en Visual Studio 2010 con la biblioteca de OpenCV para los
operadores de Dilatación y Erosión.
#include "cv.h"
#include "highgui.h"
#include "math.h"
int main()
{
IplImage* src; // imagen de color base
IplImage* colorThresh; // contendrá la imagen de color binarizada
IplImage* gray; // contendrá la imagen convertida en escala de grises
IplImage* grayThresh; // imagen binaria conseguida
// a partir de la imagen en escala de grises
int threshold = 30; // definimos el valor umbral

int maxValue = 255; // definimos el valor máximo
int thresholdType = CV_THRESH_BINARY; // definimos el
// tipo de binarización
src = cvLoadImage("lena.bmp", 1); // cargamos imagen de color

colorThresh = cvCloneImage( src ); // copiamos esa imagen de color
gray=cvCreateImage( cvSize(src->width, src->height), IPL_DEPTH_8U, 1 );
// la imagen de intensidad tendrá la misma configuración
// que la fuente pero con un solo canal
cvCvtColor( src, gray, CV_BGR2GRAY ); // pasamos la imagen de color
// a escala de grises
grayThresh = cvCloneImage( gray ); // copiamos la imagen en escala
// de grises (truco anterior)
cvNamedWindow( "src", 1 ); // representamos la imagen de color
23
cvShowImage( "src", src );
cvNamedWindow( "gray", 1 ); // representamos la imagen de intensidad
cvShowImage( "gray", gray );
cvThreshold(src, colorThresh, threshold, maxValue, thresholdType);
// binarizamos la imagen de color
cvThreshold(gray, grayThresh, threshold, maxValue, thresholdType);
// binarizamos la imagen de intensidad
cvNamedWindow( "colorThresh", 1 ); // representamos la imagen
// de color binarizada
cvShowImage( "colorThresh", colorThresh );
cvNamedWindow( "grayThresh", 1 ); // representamosla imagen
// de intensidad binarizada
cvSaveImage("camigris.bmp", gray);
cvSaveImage("camibina.bmp", grayThresh);
cvShowImage( "grayThresh", grayThresh );
cvWaitKey(0); // pulsamos tecla para terminar
cvDestroyWindow( "src" ); // destruimos todas las ventanas
cvDestroyWindow( "colorThresh" );
cvDestroyWindow( "gray" );
cvDestroyWindow( "grayThresh" );
cvReleaseImage( &src ); // eliminamos todas las imágenes
cvReleaseImage( &colorThresh );
cvReleaseImage( &gray );
cvReleaseImage( &grayThresh );
//getch (1);
return 0;
}
Resultado:
Resultado de la Dilatación. Resultado de la Erosión
24
2.2.1 Canny
El detector de bordes Canny fue desarrollado por John F. Canny en

1986. También conocido por muchos como el detector de óptimo, el algoritmo de
Canny tiene como objetivo cumplir con tres criterios principales:
 Baja tasa de error: Significado una buena detección de bordes existentes

solamente.
 Buena localización: La distancia entre los píxeles del borde y los píxeles
reales detectado borde tiene que ser minimizado.
 Respuesta mínima: Sólo una respuesta del detector al borde.
Código:
#include <stdlib.h>
#include <stdio.h>
using namespace cv;
/// variables globales

Mat src, src_gray;
Mat dst, detected_edges;
int edgeThresh = 1;
int lowThreshold;
int const max_lowThreshold = 100;
int ratio = 3;
int kernel_size = 3;
char* window_name = "Edge Map";
/**
* @funcion CannyThreshold
*/
void CannyThreshold(int, void*)
{
/// Reducir el ruido con un kernel de 3x3
blur( src_gray, detected_edges, Size(3,3) );
/// detector canny

Canny( detected_edges, detected_edges, lowThreshold, lowThreshold*ratio,
kernel_size );
/// .mouestra los resultados optenidos

dst = Scalar::all(0);
src.copyTo( dst, detected_edges);

imshow( window_name, dst );
/// cvSaveImage("lena2.bmp", &IplImage(dst));
}
25

{
/// cargar imagen
src = imread( "lena.bmp" );
if( !src.data )
{ return -1; }
/// Crear una matriz del mismo tipo y tamaño como src
dst.create( src.size(), src.type() );
/// Convertir la imagen a escala de grises

cvtColor( src, src_gray, CV_BGR2GRAY );
/// Create a window

namedWindow( window_name, CV_WINDOW_AUTOSIZE );
//cvSaveImage("11canny.jpg", &IplImage(window_name));
/// crea el Trackbar para poner el umbral
createTrackbar( "Min Threshold:", window_name, &lowThreshold, max_lowThreshold,
CannyThreshold );
/// muestra la imagen

CannyThreshold(0, 0);
/// espera asta que el usuario precione una tecla

waitKey(0);
return 0;
}
Resultado:
Imagen realzada usando el detector de bordes Canny

con Umbral = 0.
26
Capítulo 3
Sistema de Visión por
Computadora
Introducción
En este capítulo se abordan tres problemas de análisis de imágenes. El primero es el

control de calidad de botellas PET. Usando los algoritmos de mejoramiento de
contraste, binarización, ecualización del histograma y filtraje es posible detectar el
defecto de las botellas.
El segundo es el análisis de la marcha. En este se usa la resta, Binarización, Dilatación

y erosión para la segmentación de imágenes. Finalmente, se aborda el problema del
reconocimiento del lenguaje de señas. Usando la función Canny es posible extraer los
bordes de la mano de manera eficaz.
27
El sistema de visión por computadora parte de la formación de una imagen.
En esta imagen se muestra el plano imagen del cual salen 3 haces de luz. El primero
sale de forma paralela llega el lente, y le cambia la trayectoria pasando por F ’ que es su
punto focal y continua su trayectoria.
El segundo haz de luz sale de forma paralela pasando por en medio de la lente. El
tercer haz de luz pasa por F por el punto focal, pasando por la lente y continúa. En la
intersección de estos haces de luz se encuentra el plano imagen.
28
Para la adquirir las imágenes necesitamos una cámara Digital:
Sensor
Diafragma
Lente
La cámara digital esta constituida por un lente, diafragma, sensor principalmente

estos 3 elementos son de gran importancia para la adquisición de la imagen.
El diafragma nos va a permitir controlar qué tanto de luz va ingresar para el grabado
de la imagen, el sensor nos va a permitir, dependiendo de las características del
mismo, la calidad de la imagen que vamos adquirir digitalmente.
Imagen Digital
Una imagen digital es una función f(x,y) de dos dimensiones donde x e y representan
las coordenadas del plano. f(x,y) representa la intensidad o nivel de gris de la imagen
en ese punto.
𝑓𝑥,𝑦 =
Representación en
Formato de la matriz.
Cada elemento de la
Matriz es un PIXEL con
“X” filas una intensidad f.
“Y” columnas 29
3.1 Control de Calidad
La visión por computadora permite inspeccionar el proceso de producción sin fatigas

ni distracciones, facilitando la cuantificación de las variables de calidad traduciéndose
en un mejoramiento continuo.
Para llevar acabo este proyecto en el laboratorio de óptica se cuenta con los
componentes para el realizar el estudio del control de calidad.
Sistema de iluminación
Cámara CCD sensor Objeto bajo análisis Tarjeta de Adquisición

de imágenes y
Lente computadora
En este caso en particular el objeto que vamos a analizar es una botella ya que en la
boca de la botella tiene un defecto y se desea realizar un sistema que detecte este
error para que la botella se retire de la banda de producción.
30
Para ello en la investigación que se realizo podemos destacar algunas funciones las
cuales nos sirvieron para encontrar el defecto. Para esto ocupamos algunas funciones
de OpenCV, como Binarizacion, Contraste, Histograma, Ecualizacion del Histograma y
Laplciano.
Binarización
Original 𝑢𝑚𝑏𝑟𝑎𝑙 = 12
Binarizada
Cambio de Contraste:
31
Calculo del Histograma:
Ecualización del Histograma:
Filtraje usando el Laplaciano:
Como se puede observar, el defecto es detectado con mayor facilidad usando el filtro
Laplaciano.
32
3.2 Análisis de la Marcha
En la investigación de la marcha humana se retomo para la investigación de la

biblioteca de OpenCV. Así como poder brindar algunas funciones las cuales facilitaran
la investigación.
Para realizar esta investigación se tomaron las imágenes de una base de datos
llamada MOBO la cual se obtuvo de la red. Las imágenes originales que obtuvimos son
las siguientes:
Fondo Fondo + persona
El objeto a investigar en este caso es la forma de caminar de las personas para ello el
escenario fuera de la persona no nos interesa por ello se va a segmenta la imagen.
Segmentación: Su objetivo es dividir la imagen en las partes que la constituyen o los

objetos que la forman. En este proceso se diferencia el objeto y el fondo.
Para esto como tenemos 2 imágenes una sin la persona y otra con la persona para ello
vamos a realizar una resta de imágenes para poder obtener solo la persona.
Resultado de la
resta de fondo +
persona – fondo.
33
Ya que tenemos la imagen solo con la persona la tenemos que convertir a escala de
grises para posteriormente binarizarla.
Escala a grises Binaria
Al realizar la resta podemos observar que la persona pierde información en algunas

áreas. Para corregir esto, vamos a utilizar las funciones de Dilatación y Erosión.
Esta es la imagen dilatada como se puede Esta es la imagen Erosión esta función
observar se rellena algunas de las partes la reduce las áreas que tenían accesos y nos y
cual no tenia pérdida pero a las vez aparece tenemos una imagen con mayor definición.
información que teníamos o al menos no era
visible
34
Resultados:
Como se puede observar en las imágenes si hubo mejora al aplicarle las funciones de
Erosión y dilatación. Se rellenaron algunas de las partes en las cuales faltaba
información.
Es importante hacer notar que solo la información de la marcha, es decir, la parte

inferior del cuerpo es usada para el análisis de la marcha humana.
35
3.3 Lenguaje a señas
El aporte que se realizo para la investigación del lenguaje a señas es la función Canny
ya que es un detector de bordes muy preciso y nos permite ver información de la mano
sin importar la forma su posición.
En estas imágenes se muestra la mano pero pareciera a simple vista que solo tiene 3
dedos pero en realidad esta formando el numero 7 del lenguaje a señas como no se
puede ver por completo toda la mano, la función Canny nos da la información de la
mano completa si importar su posición de los dedos, como se muestra en la imagen.
Ahora el problema que se tenía era que nos arrojaba información de más ya que la
función Canny es muy precisa y muestra todos los bordes de la mano y el área que
esta de fondo de la mano. Para esto se utilizo la función de Umbral para quitar un poco
el ruido que nos estaba generando de más.
36
En la función del umbral se realizo la prueba de un umbral de 0 a 100 para ver que
nivel de umbral era el que podríamos ocupar para la función Canny.
Con un Umbral a “0” Con un Umbral a “100”
Estas images son con un umbral igual a 25 que es donde podemos observar aun los
dedos sin importar su posición y tenemos muy poco ruido o información de mas.
37
38
Capítulo 4
Conclusiones
Se revisó la biblioteca de OpenCV para el procesamiento de imágenes y se
programaron algunos algoritmos en Visual Studio 2010. OpenCV es una biblioteca muy
sencilla de utilizar ya que esta esta basado en lenguaje de programación como c/c++ y
la velocidad de procesamiento es mayor a comparación de Mathcad. Para el área de
sistemas es más familiar para el desarrollador.
Se analizaron algoritmos tales como cambio de contraste y filtraje para el

mejoramiento de imágenes. La detección de defectos se logró a partir de la imagen
mejorada usando transformación gamma =
Se analizo la segmentación de imágenes con algoritmos aritméticos y operaciones

morfológicas, tales como dilatación y erosión. En la segmentación de imágenes se
logró quitar el ruido y rellenar parte faltante en la imagen de entrada.
Se apoyó al sistema de lenguaje a señas con la función canny. La cual permitió extraer
de manera eficaz la información de señales con la mano. Se logró la detección de
bordes de las imágenes de la mano a partir de un umbral de 25.
Como trabajo a futuro se buscara implementar los algoritmos en tiempo real usando
cuda la cual esta basada en una lógica paralela. Los algoritmos para una imagen serán
extrapolados al análisis de N imágenes.
39
40
Apéndice A
Cuda utilizando la GPU mediante la
Programación en paralelo
La unidad de procesamiento gráfico o GPU es un coprocesador dedicado al

procesamiento de gráficos u operaciones de coma flotante, para aligerar la carga de
trabajo del procesador central en aplicaciones como los videojuegos y/o aplicaciones
3D interactivas.
La programación paralela es el uso de varios procesadores trabajando en conjunto

para dar solución a una tarea en común, lo que se hace es dividir el trabajo y cada
procesador realiza una porción del problema al poder intercambiar datos por una red
de interconexión o a través de memoria.
La programación paralela permite resolver problemas que no caben en un solo

procesador y que no se resuelven en un tiempo razonable, se pueden ejecutar
problemas con mayor complejidad mas rápidamente.
CUDA (Compute Unified Device

Architecture) es una arquitectura de cálculo paralelo que hace referencia tanto a un
compilador como a un conjunto de herramientas de desarrollo creadas por NVIDIA.
En General permite a los programadores usar una variación de C/C++ para codificar
algoritmos en una GPU de NVIDIA.
41
42
Referencias
• Learning OpenCV Computer Vision with the OpenCV Library
• http://opencv.willowgarage.com/wiki/
• http://fi.uaemex.mx/h.a.montes/files/TI%20Reporte%20-
%20Alan%20Barbosa%20Mendoza.pdf
• http://opencv.itseez.com/index.html
• https://groups.google.com/group/opencv-espanol?hl=es&lnk=srg
• http://docencia-eupt.unizar.es/ctmedra/tutorial_opencv.pdf
• http://tech.groups.yahoo.com/group/OpenCV/
43

OpenCV PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

OpenCV PDF

Cargado por

Copyright:

Formatos disponibles

Universidad Politécnica de

Programación en C++ usando la biblioteca

En este reporte de estadía se analizan e implementan las funciones más

Se abordan tres problemas en el contexto de Visión por Computadora. El control

En los procesos de Visión por Computadora se requiere de un análisis y procesamiento

Es una librería de tratamiento de imágenes, destinada principalmente a aplicaciones

Son un conjunto de bibliotecas de C y C++ de código libre, orientadas a visión por

Puede ser usado en Windows, Linux y MacOS

 Contienen herramientas para la interpretación de la imagen.

 Contiene una variedad de ejemplos que ayudan a comprender su

 Es una biblioteca gratuita.

 Realiza análisis de movimiento y seguimiento de objetos.

 La biblioteca esta en constante actualización al inicio de mi investigación

 Para procesar video en OpenCV es muy tardado para ellos se necesitaría de

¿Qué podemos hacer con OpenCV?

OpenCV nos permite entre muchas otras cosas:

• Operaciones básicas, como (suma, productos, integraciones, derivaciones, etc.)

• Procesado de imágenes y análisis,

• Reconstrucción 3d y calibración de la cámara,

• Interfaz gráfica y adquisición,

En este capitulo se describe la librería de OpenCV para el análisis y

Se proporciona el código de algunas tareas básicas para el mejoramiento y realce en

Estas bibliotecas se dividen en cuatro grandes grupos:

1. CXCORE: Donde se encuentran las estructuras y algoritmos básicos que

2. CV: donde están implementadas las funciones principales de

3. HighGUI: todo lo relacionado a la interfaz gráfica de OpenCV y las

4. ML: que cuenta con algoritmos de aprendizaje, clasificadores.

2. 1 Procesamiento de Imágenes y Algoritmos de visión.

El objetivo de procesamiento de imágenes es mejorar la calidad de las

1. Se encuentra la mediana (dato de en medio) de los valores permitidos para

2. Se toma uno por uno los píxeles de la imagen.

int threshold = 120; // definimos el valor umbral

src = cvLoadImage("lena.bmp", 1); // cargamos imagen de color

cvSaveImage("lena1.bmp", gray); // guardamos la imagen

Imagen escala a grises Imagen Binarizada con

El contraste es la relación entre las intensidades de los pixeles en una imagen,

El brillo es la luz que refleja o emite un cuerpo. La forma de aumentar o disminuir el

En esta operación se aumenta la intensidad en una imagen. Esta operación la realizo

Código desarrollado en Visual Studio 2010 con la biblioteca de OpenCV para el

using namespace cv;

double alpha; /**< Control de contraste simple */

int main( int argc, char** argv )

/// Inicializar los valores

/// crea la ventana

/// muestra las imagenes

/// Esperar hasta que el usuario pulsa alguna tecla

Imagen Original Imagen con cambio en contraste = 2

La aplicación pide que introduzcas un valor de contraste de 0 a 20 y un brillo de 0 a

2.1.3 Histograma y Ecualización del Histograma

using namespace std;

/// cargar imagen

/// separa las imagenes en los 3 colores ( R,G,B )

/// establecer el contador

/// establecer rangos ( para B,G,R) )

bool uniform = true; bool accumulate = false;

Mat b_hist, g_hist, r_hist;

/// calcular los histogramas:

Mat histImage( hist_h, hist_w, CV_8UC3, Scalar( 0,0,0) );

/// dibuja para cada canal de RGB

/// mostrar resultado

Imagen original Histograma por canal rojo, verde y

Ecualización del histograma.

Código desarrollado en Visual Studio 2010 con la biblioteca de OpenCV para la