J'ai une compréhension théorique de la manière dont la dilatation dans l'image binaire est effectuée.
afaik, si mon SE (élément de structuration) est ce où. représente le centre, et mon image (binaire est-ce) de sorte que le résultat de la dilatation est j'ai eu au-dessus du résultat en déplaçant une image dans 0, +1 (haut) et et -1 (gauche) direction, selon SE et en prenant l'union de tous ces trois quarts de travail. maintenant, j'ai besoin de comprendre Comment implémenter cela en C, C ++.
Je ne sais pas comment commencer et comment prendre l'union des ensembles.
J'ai pensé à représenter une image originale, trois images décalées et une image finale obtenue en prenant un syndicat; Tout à l'aide de matrice. existe-t-il un endroit où je peux obtenir une solution d'échantillon pour commencer avec ou toutes les idées pour continuer? Merci.
4 Réponses :
Il existe des tonnes d'échantillons de mise en œuvre là-bas .. Google a > Votre ami est-il :)
Modifier strong>
Ce qui suit est un pseudo-code du processus (très similaire à faire une convolution en 2D). Je suis sûr qu'il existe un moyen plus intelligent de le faire: --------------------
| | | | sz = 1;
-------------------- for (I=0 ; I<3 ; ++I)
| | (X,Y) | | for (J=0 ; J<3 ; ++J)
-------------------- vect.push_back( inImage.getPixel(X+I-sz, Y+J-sz) );
| | | |
--------------------
Et qu'en est-il du cas où nous avons la taille du noyau mxn = 1x3 où m est la largeur et n est la hauteur?
Le code n'était censé que être un contour non une mise en œuvre réelle. Mais si vous regardez de près, vous verrez que je n'ai que traité uniquement avec N * N noyaux avec N étant impair ..
:) Oui je vois ça. Je voulais juste dire que vous pouvez améliorer votre code simplement en ajoutant Kernelwidth Kernelheght et en vérifiant les frontières.
Peut-être une meilleure façon de regarder c'est comment produire un pixel de sortie de la dilatation. Pour le pixel correspondant dans l'image, alignez l'élément de structuration de manière à ce que l'origine de l'élément de structuration soit à ce pixel d'image. S'il y a un chevauchement, définissez le pixel de sortie de dilatation à cet emplacement sur 1, sinon réglez-le sur 0.
Ceci peut donc être fait simplement en boucle sur chaque pixel dans l'image et testez si l'élément de structuration correctement décalé ou non. chevauche avec l'image. Cela signifie que vous aurez probablement 4 boucles imbriquées: x img, y img, x se, y se. Donc, pour chaque pixel d'image, vous en boucle sur les pixels de l'élément structurant et voyez s'il y a des chevauchements. Cela peut ne pas être l'algorithme le plus efficace, mais c'est probablement le plus simple. P>
En outre, je pense que votre exemple est incorrect. La dilatation dépend de l'origine de l'élément structurant. Si l'origine est ... p>
en haut à gauche zéro: vous devez déplacer l'image (-1, -1), (-1,0) et (0, -1) donnent: p> en bas à droite: vous devez déplacer l'image (0,0), (1,0) et (0,1) donnant: p> 0 0 0 0 0
0 1 1 1 0
0 1 1 0 0
0 1 1 0 0
0 1 0 0 0
/* structure of the image variable
* variable n stores the order of the square matrix */
typedef struct image{
int mat[][];
int n;
}image;
/* function recieves image "to dilate" and returns "dilated"*
* structuring element predefined:
* 0 1 0
* 1 1 1
* 0 1 0
*/
image* dilate(image* to_dilate)
{
int i,j;
int does_order_increase;
image* dilated;
dilated = (image*)malloc(sizeof(image));
does_order_increase = 0;
/* checking whether there are any 1's on d border*/
for( i = 0 ; i<to_dilate->n ; i++ )
{
if( (to_dilate->a[0][i] == 1)||(to_dilate->a[i][0] == 1)||(to_dilate->a[n-1][i] == 1)||(to_dilate->a[i][n-1] == 1) )
{
does_order_increase = 1;
break;
}
}
/* size of dilated image initialized */
if( does_order_increase == 1)
dilated->n = to_dilate->n + 1;
else
dilated->n = to_dilate->n;
/* dilating image by checking every element of to_dilate and filling dilated *
* does_order_increase serves to cope with adjustments if dilated 's order increase */
for( i = 0 ; i<to_dilate->n ; i++ )
{
for( j = 0 ; j<to_dilate->n ; j++ )
{
if( to_dilate->a[i][j] == 1)
{
dilated->a[i + does_order_increase][j + does_order_increase] = 1;
dilated->a[i + does_order_increase -1][j + does_order_increase ] = 1;
dilated->a[i + does_order_increase ][j + does_order_increase -1] = 1;
dilated->a[i + does_order_increase +1][j + does_order_increase ] = 1;
dilated->a[i + does_order_increase ][j + does_order_increase +1] = 1;
}
}
}
/* dilated stores dilated binary image */
return dilated;
}
/* end of dilation */