Détection de forme différente dynamiquement comme ( le Cercle, le carré et le Rectangle ) de la caméra?

Mise à jour: Ce StackOverflow post (avec quelques beaux échantillons d'images inclus) semble avoir résolu le les cercles de détection-une partie de votre problème à tout le moins. La référence de l'excellente écriture-up, il est de pointage peuvent être trouvés sur cette page wiki (seulement grâce à la wayback machine, malheureusement).

Dans le cas où nouveau lien ne tient pas non plus, ici c'est la section pertinente:

La Détection Des Images:

Il y a un peu délicat de bits pris en charge pour détecter des cercles dans une image. Avant de traiter une image avec cvHoughCircles - la fonction de cercle de détection, vous pouvez la convertir en une image en nuances de gris et lisse. Voici la procédure générale de l'fonctions dont vous avez besoin pour une utilisation avec des exemples de leur utilisation.

Créer Une Image

En supposant que vous avez une image initiale pour le traitement appelé 'img', d'abord, vous voulez créer une image variable appelée 'gris' avec les mêmes dimensions que les img en utilisant 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 Gris

Maintenant, vous devez la convertir en gris à l'aide de cvCvtColor qui convertit entre les espaces de couleurs.

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

Image Lisse

Cela est fait de manière à empêcher beaucoup de faux cercles d'être détecté. Vous pourriez avoir besoin de jouer avec les deux derniers paramètres, notant que dont ils ont besoin pour se multiplier un nombre impair.

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

• L'image source.

de l'heure d'été

• L'image de destination.

smoothtype

Type de lissage:

• CV_BLUR_NO_SCALE (simple flou sans mise à l'échelle) - sommation sur un pixel param1×param2 quartier. Si le quartier de la taille n'est pas fixe, on peut utiliser cvIntegral fonction.
• CV_BLUR (simple flou) - sommation sur un pixel param1×param2 quartier avec par la suite une mise à l'échelle de 1/(param1•param2).
• CV_GAUSSIAN (flou gaussien) - convolution de l'image avec param1×param2 Gaussien.
• CV_MEDIAN (flou médian) - trouver la médiane de param1×param1 quartier (c'est à dire le quartier est carré).
• CV_BILATERAL (filtre bilatérale) - application bilatérale 3x3 filtrage avec color sigma=param1 et space sigma=param2

param1

• Le premier paramètre de l'opération de lissage.

param2

• Le second paramètre de l'opération de lissage.

Dans le cas d'un simple échelle/non mis à l'échelle et flou Gaussien si param2 est égale à zéro, il est mis à param1

Détecter à l'aide de Hough Cercle

La fonction cvHoughCircles est utilisé pour détecter des cercles sur le gris de l'image. De nouveau, les deux derniers paramètres peuvent avoir besoin d'être bricolé avec.

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 section appropriée =========

Le reste de cette page wiki est vraiment très bon (bien que, je ne vais pas recopier ici, car le reste est hors-sujet pour la question d'origine et StackOverflow a une limite de taille pour les réponses). J'espère que c' lien à la copie mise en cache sur la Wayback machine vont continuer à travailler indéfiniment.

Réponse précédente Avant ma mise à Jour:

Grand! Maintenant que vous avez publié quelques exemples, je peux voir que vous n'êtes pas seulement après que des rectangles, des carrés, des rectangles et des cercles, vous aussi vous voulez trouver ces formes dans un environnement 3D, donc potentiellement de la chasse pour les cas spéciaux de parallélogrammes et ovales qu'à partir de l'image vidéo à l'image de la vidéo peut éventuellement se révéler être des rectangles, des carrés et/ou des cercles (en fonction de la façon dont vous déplacez l'appareil photo).

Personnellement, je trouve qu'il est plus facile de travailler par l'intermédiaire d'un problème moi-même que d'essayer de comprendre comment utiliser un existant (souvent très mature) de la bibliothèque. Ce n'est pas de dire que mon travail sera meilleure que celle de la maturité de la bibliothèque, il ne sera certainement pas. C'est juste que une fois que je peux travailler moi-même à travers un problème, alors il devient plus facile pour moi de comprendre et d'utiliser une bibliothèque (la bibliothèque elle-même qui va souvent beaucoup plus rapide et plus intelligent que celui de ma propre solution).

Donc la prochaine étape, je voudrais prendre est de changer l'espace colorimétrique de l'image bitmap en niveaux de gris. Une image bitmap de couleur, j'ai du mal à comprendre et j'ai du mal à manipuler, en particulier car il ya tellement de nombreuses manières différentes, il peut être représenté, mais un bitmap en niveaux de gris, qui est à la fois beaucoup plus facile à comprendre et à manipuler. Pour une image bitmap en niveaux de gris, imaginez une grille de valeurs, chaque valeur représentant une autre intensité de la lumière.

Et pour l'instant, nous allons limiter la portée du problème à trouver des parallélogrammes et des ovales à l'intérieur d'une statique 2D de l'environnement (nous allons vous inquiétez à propos de la transformation des environnements 3D et en mouvement des images vidéo plus tard, ou devrais-je dire, vous vous inquiétez à propos de cette partie de vous-même puisque le problème est déjà trop compliqué pour moi).

Et pour l'instant aussi, nous allons vous inquiétez pas ce que l'outil ou la langue que vous utilisez. Juste à utiliser ce qui est plus facile et la plus expeditive. Par exemple, à peu près tout peut être inclus dans le script pour convertir automatiquement une image en niveaux de gris, en supposant que le temps n'est pas question. ImageMagick, Gimp, Marvin, Traitement, Python, Ruby, Java, etc.

Et avec l'un de ces outils, il devrait être facile pour le groupe de pixels avec assez similaire intensités (pour rendre les calculs plus faciles à gérer et à trier chaque pixel de coordonnées dans un tableau différent pour chaque intensité de la lumière seau. En d'autres termes, il ne devrait pas être trop difficile d'organiser une sorte de brut de l'histogramme de tableaux triés en fonction de l'intensité qui contiennent de chaque pixel x et y des positions.

Après cela, le problème devient un problème de plus comme cette une (qui peut être trouvé sur StackOverflow) et peut donc être travaillé avec la solution proposée.

Et une fois que vous êtes en mesure de travailler à travers le problème de cette façon, la conversion de la solution que vous venez avec un meilleur langage adapté à la tâche ne devrait pas être trop difficile. Et il devrait être beaucoup plus facile aussi de comprendre et d'utiliser la fonction sous-jacente de toute bibliothèque de fin de choix pour la tâche. Au moins, c'est ce que j'espère, puisque je ne suis pas assez familier et je ne peux pas vraiment vous aider avec la OpenCV les bibliothèques elles-mêmes.