Detection de contours d'une image

Version imprimable

19/05/2009, 02h23
foufar2009

Detection de contours d'une image

Bonsoir,
Je veut r�aliser une application en Builder pour detecter les contours des objets dans une image, aidez moi pour r�aliser cette application.
Je suis en attente de votre suggestions,
et merci d'avance.
19/05/2009, 02h50
Crayon

Salut voici un liens qui pourrait t'aider:
http://www.developpez.net/forums/d68...ction-contour/

PS: J'ai jamais tester OpenCV sous C++Builder :P

Encore des liens
En fran�ais:
http://fr.wikipedia.org/wiki/Algorithme_de_Canny
En anglais (plus complet):
http://en.wikipedia.org/wiki/Canny_edge_detector
19/05/2009, 11h00
dz_robotix

le mieux c'est d'utliser opencv comme te l'a signal� crayon.

ou d'appliquer des filtre d�rivateur (canny, laplace,...) en gros chaque pixel de ton image sera multipli� par la matrice de d�finition des ces filtre.
19/05/2009, 19h42
foufar2009

Merci pour les liens,
Je suis int�ress� � r�aliser un des filtres, est ce qu'il y a un code exemple pour que je puisse inspirer depuis ce code, en builder ou delphi et merci

Salut,
j'ai fait un grand effort mais je peux pas appliquer le filtre PREWITT sur une image couleur ou noir et blanc, la seule chose que j'ai pu programmer c'est le flou uniform (matrice (1,1,1),(1,1,1),(1,1,1)), mon pb c comment appliquer ces deux matrices
M1=(-1,0,1)
(-1,0,1)
(-1,0,1)

M1=(-1,-1,-1)
( 0, 0, 0)
( 1, 1, 1)

et sommer les r�sultats obtenus avec les 2 noyaux (M1 et M2)

Voici mon code de flou uniform, SVP corriger moi pour faire PREWITT et merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
void BlurBitmap(Graphics::TBitmap* ABitmap) {
 
    assert(ABitmap != NULL);
    ABitmap->PixelFormat = pf24bit;
 
    const float h[3][3] =
        {{1, 1, 1},
         {1, 1, 1},
         {1, 1, 1}};
 
    const int width = ABitmap->Width;
    const int height = ABitmap->Height;
 
    for (int y = 1; y < height - 1; ++y) {
 
        RGBTRIPLE* line_prev =
            static_cast<RGBTRIPLE*>(ABitmap->ScanLine[y - 1]);
        RGBTRIPLE* line_curr =
            static_cast<RGBTRIPLE*>(ABitmap->ScanLine[y]);
        RGBTRIPLE* line_next =
            static_cast<RGBTRIPLE*>(ABitmap->ScanLine[y + 1]);
 
        for (int x = 1; x < width - 1; ++x) {
 
            float blue =
                (h[0][0] * static_cast<float>(line_prev[x - 1].rgbtBlue)) +
                (h[0][1] * static_cast<float>(line_prev[x].rgbtBlue)) +
                (h[0][2] * static_cast<float>(line_prev[x + 1].rgbtBlue)) +
                (h[1][0] * static_cast<float>(line_curr[x - 1].rgbtBlue)) +
                (h[1][1] * static_cast<float>(line_curr[x].rgbtBlue)) +
                (h[1][2] * static_cast<float>(line_curr[x + 1].rgbtBlue)) +
                (h[2][0] * static_cast<float>(line_next[x - 1].rgbtBlue)) +
                (h[2][1] * static_cast<float>(line_next[x].rgbtBlue)) +
                (h[2][2] * static_cast<float>(line_next[x + 1].rgbtBlue));
 
            float green =
                (h[0][0] * static_cast<float>(line_prev[x - 1].rgbtGreen)) +
                (h[0][1] * static_cast<float>(line_prev[x].rgbtGreen)) +
                (h[0][2] * static_cast<float>(line_prev[x + 1].rgbtGreen)) +
                (h[1][0] * static_cast<float>(line_curr[x - 1].rgbtGreen)) +
                (h[1][1] * static_cast<float>(line_curr[x].rgbtGreen)) +
                (h[1][2] * static_cast<float>(line_curr[x + 1].rgbtGreen)) +
                (h[2][0] * static_cast<float>(line_next[x - 1].rgbtGreen)) +
                (h[2][1] * static_cast<float>(line_next[x].rgbtGreen)) +
                (h[2][2] * static_cast<float>(line_next[x + 1].rgbtGreen));
 
            float red =
                (h[0][0] * static_cast<float>(line_prev[x - 1].rgbtRed)) +
                (h[0][1] * static_cast<float>(line_prev[x].rgbtRed)) +
                (h[0][2] * static_cast<float>(line_prev[x + 1].rgbtRed)) +
                (h[1][0] * static_cast<float>(line_curr[x - 1].rgbtRed)) +
                (h[1][1] * static_cast<float>(line_curr[x].rgbtRed)) +
                (h[1][2] * static_cast<float>(line_curr[x + 1].rgbtRed)) +
                (h[2][0] * static_cast<float>(line_next[x - 1].rgbtRed)) +
                (h[2][1] * static_cast<float>(line_next[x].rgbtRed)) +
                (h[2][2] * static_cast<float>(line_next[x + 1].rgbtRed));
 
            blue = blue / 9; // 1 * 9
            green = green / 9; // 1 * 9
            red = red / 9; // 1 * 9
 
            line_curr[x].rgbtBlue = FIX0(CLIP255(blue));
            line_curr[x].rgbtGreen = FIX0(CLIP255(green));
            line_curr[x].rgbtRed = FIX0(CLIP255(red));
        }
    }
}

20/05/2009, 20h56
SmileSoft

salut,

la m�thode est bien expliqu�e dans ce lien
21/05/2009, 09h11
Patrick Seuret

La d�tection des contours se fait avec un filtre passe-haut.

Tu trouveras plus d'explications sur cette page:
http://fr.wikipedia.org/wiki/Traitem...on_de_contours

Et une approche plus pratique sur le filtre de Canny:
1) Faire un premier filtrage pour �liminer les valeurs trop locales (matrice h)
2) Appliquer le filtre passe-haut (matrices Gx et Gy)
3) Faire un second filtre de seuillage pour �liminer les artefacts

Salut, voici une fonction pour un filtre passe haut pour niveau de gris. Le code reste � v�rifier il a �t� �cris il y a plusieurs ann�es :D

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
void HighPass(Graphics::TBitmap *ImAModifier)
{
int y, x, i, j, sum=0;
int PixelValue;
int Mask[3][3] = {{-1, -1, -1,}, {-1, 8, -1}, {-1, -1, -1}};
Graphics::TBitmap *ImTemp = new Graphics::TBitmap;
 
ImTemp->Assign(ImAModifier);
 
for (y=1; y<=ImAModifier->Height-1; y++)
  for (x=1; x<=ImAModifier->Width-1; x++){
 
    /* Application du masque */
    for (j=-1; j<=1; j++)
      for (i=-1; i<=1; i++){
        PixelValue = ((ImTemp->Canvas->Pixels[x+i][y+j]) & 0x0000FF);
        sum += PixelValue * Mask[i+1][j+1];
      }
 
    sum = sum/9.0;
    sum = (sum << 16) | (sum << 8) | sum;
    ImAModifier->Canvas->Pixels[x][y] = (TColor) sum;
    sum=0;
  }
}

23/05/2009, 20h01
foufar2009

Merci, pour tous �a, finalement j'ai trouv� l'erreur : j'ai utilis� un seul bitmap pour l'image source et destination!!! :oops::oops:

Mais c'est quoi un filtre de seuillage ?