Top Ad unit 728 × 90

Recientes

recent

Curso OpenCV y C++ con Visual Studio 2013 (7-25) - Detectar Líneas en OpenCv

Si queremos detectar líneas, círculos y otras formas en una imagen en OpenCV podemos utilizar las funciones HoughLines y HoughLinesP, ambas funciones usan el método HoughTransform.

Transformada de Hough
Esta transformada intenta buscar figuras geométricas simples en una imagen.  Cuando se procesa emplea toda la imagen, haciéndola robusta ante la presencia de ruido o las discontinuidades de las etapas previas, ya que para hacer esta transformada primero hemos de convertir la imagen a escala de grises con los bordes seleccionados, o sea tenemos que aplicar un detector de bordes.  A partir de aquí el algoritmo intentará buscar figuras geométricas, como pueden ser línea, círculos elipses.

Detección de Líneas
Considerando un punto de coordenadas (Xi,Yi), como elemento que representa un borde; sobre éste pasarán infinitas rectas:
                  Yi=aXi+b   (1)

Que es la ecuación de una recta, en la que tendremos que calcular los parámetros a y b.  Si despejamos b.
                 b=Yi-aXi  (2)

Al variar el parámetro a desde menos infinito hasta mas infinito se obtendrá los infinitos valores de b. La representación geométrica de  b = Yi − aXi , es una recta. La característica interesante de esta presentación consiste que si dos puntos que pertenezcan a una misma recta (1) implicará que tengan el mismo valor de a y b. 

Entonces la transformada de Hough aplica este concepto a las líneas rectas de la imagen. Discretizando la imagen desde un valor de "a mínimo" hasta un valor de "a máximo" y desde "b mínimo" hasta "b máximo" creando unas rejillas de acumulación. Por cada punto, considerado como borde, se hace recorrer el rango de a obteniendo b. Por cada valor de a y b se pone un voto.  Al finalizar, aquellos valores con más votos indicaran la presencia de rectas en la imagen, cuyo modelo corresponderá con los valores de a y b.

Para la detección de líneas usamos dos métodos: 

El método estándar HougLines Standard Hough Line Transform
El método probabilístico es más eficiente HougLinesP Probabilistic Line Transform.
Antes de usar alguna de estas funciones primero aplicaremos dos funciones a la imagen, Canny para detectar los bordes de la imagen y cvtColor para cambiar la imagen de escala de grises a BGR y poder mostrar los resultados.
Canny(src, dst, 50, 200, 3);cvtColor(dst, cdst, CV_GRAY2BGR);

1. Aplicar el método HoughLines con los parámetros indicados, se dibujan la líneas encontradas:
HoughLines(dst, lines, 1, CV_PI / 180, 200, 0, 0);
  • dst: proporcionado por Canny. 
  • lines: almacena las lineas detectadas. 
  • rho : usaremos 1 pixel. 
  • theta: usaremos 1 grado (CV_PI/180). 
  • threshold: numero mínimo de líneas a detectar. 
  • srn and stn: zero por defecto. 

2. Para aplicar el método HoughLinesP se hace  de manera similar solo cambian algunos parámetros y la manera como devuelve las lineas:
HoughLinesP(dst, lines, 1, CV_PI / 180, 50, 50, 10);
  • dst: proporcionado por Canny.
  • lines: almacena las lineas detectadas.
  • rho : usaremos 1 pixel.
  • theta: usaremos 1 grado (CV_PI/180).
  • threshold: numero mínimo de líneas a detectar.
  • minLinLength: mínimo de puntos que forman una línea.


Código: Ejemplo de detectar Líneas en OpenCv y C++


// CursoOpenCV2410.cpp: Juan Carlos Arcila Díaz.
#include "stdafx.h"
#include "opencv2\opencv.hpp"

using namespace cv;
int _tmain(int argc, _TCHAR* argv[])
{
      //Leemos la imagen de Archivo
      cv::Mat src = cv::imread("D:\\pruebaopencv\\campo.jpg", 0);
      //Evaluamos si se pudo leer la imagen
      if (src.empty())
      {
            printf("Eror al Intentar Abrir la Imagen");
            return -1;
      }

      //Declaramos dos imágenes más
      cv::Mat dst, cdst;
      //Aplicamos el filtro Canny a la imagen src y la guardamos en dst
      Canny(src, dst, 50, 200, 3);
      //Convertimos la imagen dst a escala de grises y la guardamos en cdst
      cvtColor(dst, cdst, CV_GRAY2BGR);

      #if 0 //Cambiar a 1 para usar el método estándar
            vector lines;
            HoughLines(dst, lines, 1, CV_PI / 180, 200, 0, 0);
            //Almacenamos todos los puntos qe forman las líneas en el vector
            for (size_t i = 0; i < lines.size(); i++)
            {
                  float rho = lines[i][0], theta = lines[i][1];
                  Point pt1, pt2;
                  double a = cos(theta), b = sin(theta);
                  double x0 = a*rho, y0 = b*rho;
                  pt1.x = cvRound(x0 + 1000 * (-b));
                  pt1.y = cvRound(y0 + 1000 * (a));
                  pt2.x = cvRound(x0 - 1000 * (-b));
                  pt2.y = cvRound(y0 - 1000 * (a));
                  line(cdst, pt1, pt2, Scalar(0, 0, 255), 3, CV_AA);
            }
      #else
            vector lines;
            HoughLinesP(dst, lines, 1, CV_PI / 180, 50, 50, 10);
            for (size_t i = 0; i < lines.size(); i++)
            {
                  Vec4i l = lines[i];
                  line(cdst, Point(l[0], l[1]),
                        Point(l[2], l[3]), Scalar(0, 0, 255),
                        3, CV_AA);
            }
      #endif
     
      //Mostramos la imagen Original y la imagen con las líneas detectadas
      imshow("Imagen Original", src);
      imshow("Lineas Detectadas", cdst);
      waitKey();
}
//
Saludos Imperio, un abrazo a la distancia!
Curso OpenCV y C++ con Visual Studio 2013 (7-25) - Detectar Líneas en OpenCv Reviewed by Juan Carlos Arcila Díaz on 5:56 Rating: 5

No hay comentarios:

All Rights Reserved by www.IncanatoIT.com - Desarrollando Software © 2014 - 2015
Powered By Blogger, Designed by Sweetheme

Formulario de contacto

Nombre

Correo electrónico *

Mensaje *

IncanatoIt.com. Con la tecnología de Blogger.