Discussion :

[foufar2009]

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.

[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

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

[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.

[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

[foufar2009]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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));
        }
    }
}

[SmileSoft]

salut,

la méthode est bien expliquée dans ce lien

[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

[Crayon]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
  }
}

[foufar2009]

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

Mais c'est quoi un filtre de seuillage ?