android - studio - figuras canvas html5

Detección de diferentes formas de forma dinámica(círculo, cuadrado y rectángulo) de la cámara?

Question

Quiero crear una aplicación para detectar la forma de los objetos como (círculo, cuadrado y rectángulo solo formas de geometría) que no deberían usar Marker less o Edge para detectar la forma en aumento.

He usado las siguientes cosas para esto, como pasé por los procedimientos del tutorial que ya existen en el metaio sdk

1) Metaio: http://dev.metaio.com/sdk/tutorials/hello-world/

2) OpenCV: http://docs.opencv.org/doc/tutorials/imgproc/imgtrans/canny_detector/canny_detector.html#canny-detector

esto es lo que intenté implementar.

Formas de geometría: 1) Círculo en tiempo real podría ser cualquier objeto circular ->

2) Square en tiempo real podría ser cualquier objeto cuadrado ->

3) Rectángulo en tiempo real podría ser cualquier objeto rectangular ->

¿Cómo puedo lograr este escenario del aumento?

Gracias por adelantado

Answer 1

Actualización: esta publicación de StackOverflow (con algunas buenas imágenes de muestra incluidas) parece haber resuelto la detección de círculos, parte de tu problema al menos. La referencia de la excelente reseña que está señalando se puede encontrar en esta página wiki (solo a través de la máquina de retorno, desafortunadamente).

En caso de que el nuevo enlace no sea válido, aquí está la sección relevante:

Detectando imágenes:

Hay algunos bits que hay que cuidar para detectar círculos en una imagen. Antes de procesar una imagen con cvHoughCircles : la función para la detección de círculo, es posible que desee convertirla primero en una imagen gris y suavizarla. A continuación se muestra el procedimiento general de las funciones que necesita usar con ejemplos de su uso.

Crear imagen

Supongamos que tiene una imagen inicial para procesar llamada ''img'', primero quiere crear una variable de imagen llamada ''gris'' con las mismas dimensiones que img usando cvCreateImage .

IplImage* gray = cvCreateImage( cvGetSize(img), 8, 1 );
// allocate a 1 channel byte image
CvMemStorage* storage = cvCreateMemStorage(0);
IplImage* cvCreateImage(CvSize size, int depth, int channels);
size: cvSize(width,height);
depth: pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16U,
IPL_DEPTH_16S, IPL_DEPTH_32S, IPL_DEPTH_32F, IPL_DEPTH_64F
channels: Number of channels per pixel. Can be 1, 2, 3 or 4. The channels
are interleaved. The usual data layout of a color image is
b0 g0 r0 b1 g1 r1 ...

Convertir a gris

Ahora necesita convertirlo a gris usando cvCvtColor que convierte espacios de color.

cvCvtColor( img, gray, CV_BGR2GRAY );
cvCvtColor(src,dst,code); // src -> dst
code = CV_<X>2<Y>
<X>/<Y> = RGB, BGR, GRAY, HSV, YCrCb, XYZ, Lab, Luv, HLS
e.g.: CV_BGR2GRAY, CV_BGR2HSV, CV_BGR2Lab

Imagen suave

Esto se hace para evitar que se detecten muchos círculos falsos. Es posible que deba jugar con los dos últimos parámetros, señalando que necesitan multiplicar a un número impar.

cvSmooth( gray, gray, CV_GAUSSIAN, 9, 9 );
// smooth it, otherwise a lot of false circles may be detected
void cvSmooth( const CvArr* src, CvArr* dst,
int smoothtype=CV_GAUSSIAN,
int param1, int param2);

src

• La imagen de origen.

dst

• La imagen de destino.

smoothtype

Tipo de suavizado:

• CV_BLUR_NO_SCALE (desenfoque simple sin escala) - suma sobre un píxel param1 × barrio param2. Si el tamaño del vecindario no es fijo, se puede usar la función cvIntegral.
• CV_BLUR (desenfoque simple) - suma sobre un píxel param1 × barrio param2 con escalamiento posterior en 1 / (param1 • param2).
• CV_GAUSSIAN (desenfoque gaussiano) - imagen convolucional con param1 × param2 Gaussian.
• CV_MEDIAN (desenfoque mediano) - encontrando la mediana del param1 × param1 vecindario (es decir, el vecindario es cuadrado).
• CV_BILATERAL (filtro bilateral) - aplicando filtrado bilateral 3x3 con color sigma=param1 y space sigma=param2

param1

• El primer parámetro de la operación de suavizado.

param2

• El segundo parámetro de la operación de suavizado.

En caso de desenfoque gaussiano escalado / no escalado y param2 si param2 es cero, se establece en param1

Detectar usando Hough Circle

La función cvHoughCircles se usa para detectar círculos en la imagen gris. De nuevo, los últimos dos parámetros podrían necesitar ser manipulado.

CvSeq* circles =
cvHoughCircles( gray, storage, CV_HOUGH_GRADIENT, 2, gray->height/4, 200, 100 );
CvSeq* cvHoughCircles( CvArr* image, void* circle_storage,
int method, double dp, double min_dist,
double param1=100, double param2=100,
int min_radius=0, int max_radius=0 );

======= Fin de la sección relevante =========

El resto de esa página wiki en realidad es muy buena (aunque, no voy a volver a copiarla aquí ya que el resto está fuera del tema de la pregunta original y StackOverflow tiene un límite de tamaño para las respuestas). Afortunadamente, ese enlace a la copia en caché en la máquina de Wayback seguirá funcionando indefinidamente.

Respuesta anterior antes de mi actualización:

¡Estupendo! Ahora que ha publicado algunos ejemplos, puedo ver que no solo busca rectángulos, rectángulos cuadrados y círculos, sino que también desea encontrar esas formas en un entorno 3D, lo que permite buscar casos especiales de paralelogramos y óvalos que provengan del video. el fotograma al fotograma de video finalmente puede revelarse como rectángulos, cuadrados y / o círculos (dependiendo de cómo se desplaza la cámara).

Personalmente, me resulta más fácil resolver un problema yo mismo que tratar de comprender cómo usar una biblioteca existente (muchas veces muy madura). Esto no quiere decir que mi propio trabajo será mejor que una biblioteca madura, ciertamente no lo será. Es solo que una vez que puedo resolver un problema, me resulta más fácil comprender y usar una biblioteca (la biblioteca misma, que a menudo se ejecutará mucho más rápido y más inteligentemente que mi propia solución).

Entonces, el siguiente paso que tomaría es cambiar el espacio de color del mapa de bits en escala de grises. Un mapa de bits en color, tengo problemas para entenderlo y tengo problemas para manipularlo, especialmente porque hay muchas maneras diferentes de representarlo, pero un mapa de bits en escala de grises, que es mucho más fácil de entender y manipular. Para un mapa de bits en escala de grises, solo imagine una grilla de valores, con cada valor representando una intensidad de luz diferente.

Y, por ahora, limitemos el alcance del problema a la búsqueda de paralelogramos y óvalos dentro de un entorno 2D estático (nos preocuparemos por procesar entornos 3D y mover cuadros de video más adelante, o debería decir, usted mismo se preocupará por esa parte desde ese problema ya se está volviendo demasiado complicado para mí).

Y por ahora también, no nos preocupemos por la herramienta o el lenguaje que use. Simplemente use lo que sea más fácil y más expeditivo. Por ejemplo, casi cualquier cosa puede escribirse para convertir automáticamente una imagen a escala de grises suponiendo que el tiempo no es un problema. ImageMagick, Gimp, Marvin , procesamiento , Python, Ruby, Java, etc.

Y con cualquiera de esas herramientas, debería ser fácil agrupar píxeles con intensidades suficientemente similares (para hacer los cálculos más manejables) y ordenar cada una de las coordenadas de los píxeles en una matriz diferente para cada cubo de intensidad de luz. En otras palabras, no debería ser demasiado difícil organizar algún tipo de histograma crudo de arreglos ordenados por intensidad que contienen las posiciones xey de cada píxel.

Después de eso, el problema se convierte en un problema más parecido a este (que se puede encontrar en StackOverflow) y, por lo tanto, se puede trabajar con su solución sugerida.

Y una vez que sea capaz de resolver el problema de esa manera, entonces la conversión de la solución que se le presente a un mejor lenguaje adecuado para la tarea no debería ser demasiado difícil. Y también debería ser mucho más fácil comprender y utilizar la función subyacente de cualquier biblioteca existente que finalice eligiendo también para la tarea. Al menos, eso es lo que espero, ya que no estoy lo suficientemente familiarizado y realmente no puedo ayudarte con las bibliotecas de OpenCV.