Discussion :

[bahiatoon]

Je voudrai créer un disque 2D (élément structurant) centré en n’importe quel pixel d’une image, et de rayon quelconque
Le problème est que je n’ai pas trouvé une idée qui puisse me permettre de changer à chaque fois le rayon du cercle

Si vous avez une idée laissez moi un message

[Crayon]

Avec un peu de Trigonométrie tu devrais y arriver:
http://fr.wikipedia.org/wiki/Trigono...onom.C3.A9trie

S'il te manque de théorie sur le cercle:
http://fr.wikipedia.org/wiki/Cercle_...om%C3%A9trique

[yarp]

Super la trigo, depuis le temps que j'en cherchais - sans chercher
Merci pour les liens Crayon.

Yarp

[bahiatoon]

Je me suis mal expliqué dans mon dernier message ,

je n'arrive pas à trouver une Boucle qui puisse me permettre de créer un disque de rayon "n"

Veuillez trouver ci-joint un exemple de disque de rayon=3

A+

[blondelle]

Salut bahiatoon:
Peut etre en utilisant la fonction Ellipse

[bahiatoon]

Peut etre en utilisant la fonction Ellipse

STP, peux tu me donner un exemple de code

A+

[blondelle]

Tire de l'aide en ligne.

Draws the ellipse defined by a bounding rectangle on the canvas.
void __fastcall Ellipse(int X1, int Y1, int X2, int Y2);
void __fastcall Ellipse(TRect Rect);
Description
Call Ellipse to draw a circle or ellipse on the canvas. Specify the bounding rectangle either by giving
The top left point at pixel coordinates (X1, Y1) and the bottom right point at (X2, Y2).
A TRect value.
If the bounding rectangle is a square, a circle is drawn.
The ellipse is outlined using the value of Pen, and filled using the value of Brush.
Note: On Windows 95, the sums X1 + X2 and Y1 + Y2 cannot exceed 32768. Also, the sum X1 + X2 + Y1 + Y2 cannot exceed 32768.

Exemple

The following example paints a cross-hatched ellipse onto Image1 which is a TImage on the form when the user clicks on Button1.
void __fastcall TForm1::Button1Click(TObject *Sender)
{
TCanvas *pCanvas = Image1->Canvas;
pCanvas->Brush->Color = clRed;
pCanvas->Brush->Style = bsDiagCross;
pCanvas->Ellipse(0, 0, Image1->Width, Image1->Height);
}

[henderson]

Salut !

On peut traiter tous les pixels du carré circonscrit au disque.
On sait que dans ce cas, on aura du déchet, car seuls les points qui satisfont à d <= r appartiennent au disque, où d est la distance angulaire du point par rapport au centre du disque et r son rayon.

Par exemple :

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
TPoint Centre;
double Rayon;
double Distance;
for(int y = - Rayon, y <= Rayon; y++)
    {
    for(int x = - Rayon, x <= Rayon; x++)
        {
        Distance = hypot(dx, dy);
        if(distance <= Rayon)
            {
            // le pixel appartient au disque
            // position du pixel sur l'image
            // Centre.x + x
            // Centre.y + y
            }
        }
    }

On peut faire de même à partir du centre du disque, de carré en carré jusqu'au carré circonscrit.
La encore on aura le même déchet !

Peut-être existe t-il une autre méthode (sans déchets) en s'appuyant sur une suite de cercles concentriques et en calculant chaque point utile sur chaque cercle.
A ce stade, je pense que l'on risque peut-être d'avoir une perte de pixels à cause des approximations.
Il faudrait en effet calculer le rayon par demi pixels.
Le problème est alors de calculer le nombre de points utiles pour chaque cercle, ce qui permettrait de calculer un angle pour la progression.
Je ne sais pas s'il existe une formule (simple ou complexe) allant dans ce sens !

A plus !

[Neilos]

Il faut travailler avec le cosinus.
De plus avec tous les axes de symétrie d'un cercle on peut se permettre de ne calculer que le 4 des points du cercle pour en tracer l'ensemble.

Enfin le plus simple reste la fonction Ellipse du TCanvas, pas besoin de réinventer la roue.

Si malgré tout tu veux écrire ta propre fonction je détaillerais l'utilisation du cosinus si nécessaire.

[henderson]

Salut !

Je ne sais pas à qui ni à quoi j'ai à faire ici !
Donc, compte tenu de la miniature jointe, j'ai pensé qu'on pouvait être dans un contexte particulier, pas forcément pour réinventer la roue mais pour avoir une vision du disque pixel par pixel.
Si c'est juste TCanvas::Ellipse... alors je crois que je vais retourner profiter du soleil !

A plus !

[Mat.M]

Je voudrai créer un disque 2D (élément structurant) centré en n’importe quel pixel d’une image, et de rayon quelconque
Le problème est que je n’ai pas trouvé une idée qui puisse me permettre de changer à chaque fois le rayon du cercle

Si vous avez une idée laissez moi un message

pour tracer un cercle j'ai déjà répondu ET donné un exemple en C++ dans le forum Algorithmes et développement jeux ;
faire une recherche sur ces forums ou dev jeux

[Neilos]

Ouais mais TCanvas::Ellipse sait le faire....

[bahiatoon]

MERCI pour vos réponses

henderson à écrit:
Je ne sais pas à qui ni à quoi j'ai à faire ici !

Je veux faire passer un disque sur une image pixel par pixel, je ne sais pas si vous avez entendu parlé de la morphologie mathématique, le disque represente l'élément structurant.

A+

[Neilos]

Tu entends quoi par faire passer pixel par pixel ?
Le dessiner ?
Quel est l'intérêt de tout ça au final ?

[henderson]

Salut !

J'ai pris un bon coup de soleil !
Alors... c'était quoi au juste ?

A plus !

[bahiatoon]

Tu entends quoi par faire passer pixel par pixel ?
Le dessiner ?

Non ce n'est pas necessaire de le dessiner,

Je prends chaque pixel de l'image et je crée un disque centré en celui-ci , ensuite j'attribue au pixel central la valeur maximale de tous les pixels appartenant au disque.

henderson a écrit:
J'ai pris un bon coup de soleil !

Tu as de la chance, moi le soleil je ne l'ai pas vu depuis longtemps

A+

[Neilos]

Je balayerais dans toutes les directions les différents points en partant du centre et en calculant à chaque fois la distance euclidienne au centre...

Après tu dois pouvoir optimiser ça facilement mais c'est le principe que je suivrais...

[henderson]

Salut !

J'ai quand même fait une erreur dans le code que j'ai donné :

Code :

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

Distance = hypot(x, y);

Je me doutais un peu qu'il s'agissait de traiter les pixels... et non pas de dessiner un disque !

A plus !

[bahiatoon]

Salut,

En suivant vos explications, j'ai écrit un petit programme

mais je n'ai toujours pas obtenu le résultat escompté

Voici le code pour un rayon=10:

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
 
int tri[1000];
int k;
double Distance, max;
H=Image1->Picture->Bitmap->Height;
W=Image1->Picture->Bitmap->Width;
for(int x=0;x<W;x++)
        for(int y=0;y<H;y++)
        {
        a=Image1->Picture->Bitmap->Canvas->Pixels[x][y];
        b=a%256;
        g=(a/256)%256;
        r=(a/(256*256))%256;
        image[x][y]=(int)(r*0.299+g*0.587+b*0.114);
        }
for(int x=1;x<W;x++)
        for(int y=1;y<H;y++)
        {       k=1;
                for (int i=x-10;i<=x+10;i++)
                        for(int j=y-10;j<=y+10;j++)
                        {
                        Distance = sqrt(pow(image[x][y],2)+ pow(image[i][j],2));
                        if (Distance<=10)
                                {
                                tri[k]=image[i][j];
                                k=k+1;
                                }
                        }
                        max=tri[1];
                        for(int l=2;l<=k;l++)
                                        {
                                        if (max<tri[l]) max=tri[l];
                                        }
 
        Image[x][y]= max;
        }
for(int x=1;x<W;x++)
        for(int y=1;y<H;y++)
        {
        Image1->Canvas->Pixels[x][y]=(TColor)((int)(Image[x][y]+256*Image[x][y]+256*256*Image[x][y]));
        }

Si vous avez detecté l'erreur n'hésitez surtout pas à me laisser un message

A+

[henderson]

Salut !

Pour les nivaux de gris :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
//Rem : Byte Image[..][..]; //le type Byte est bien suffisant
 
COLORREF color;
for(int x=0; x<W; x++)
    {
    for(int y=0;y<H;y++)
        {
        color = Image1->Picture->Bitmap->Canvas->Pixels[x][y];
        Image[x][y] = (Byte)(((GetBValue(color) * 11) + (GetGValue(color) * 59) + (GetRValue(color) * 30)) / 100);
        }
    }

Suite du code... il faudrait, je pense, faire autrement :

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
int px, py;
double d;
int max;
for(int x = 0; x < W; x++)
    {
    for(int y = 0; y < H; y++)
        {
        max = 0;
        //le référentiel du disque
        for (int i = -10; i <= +10; i++)
            {
            px = x + i; //abscisse réelle du point dans le tableau
            for(int j = -10; j <= +10; j++)
                {
                py = y + j; //ordonnée réelle du point dans le tableau
                //le point appartient-il au tableau
                if((px >= 0) && (px < W) && (py >= 0) && (py < W))
                    {
                    //le point appartient-il au disque ? 
                    d = hypot(i,j); 
                    if (d <= 10.0)
                        {
                        //on a donc identifié un point et on calcule le max 
                        if(Image[px][py] > max) max = Image[px][py];
                        }
                    }
                }
            }
        //le centre du référentiel prend pour valeur ici, la valeur max rencontrée
        //à la surface de son disque
        Image[x][y]= (Byte)max;
        }
    }

Code :

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

1
2
3
4
5
6
7
8
9
10
11
//Affichage du résultat :
Byte b;
for(int x = 0; x < W; x++)
    {
    for(int y = 0; y < H; y++)
        {
        b = Image[x][y]; 
        //b est un niveau de gris à reporter dans les 3 composantes
        Image1->Canvas->Pixels[x][y]=(TColor)RGB(b, b, b);
        }
    }

Dans un premier temps, vérifier si le bitmap de l'image est au moins un 24 bits.
Si ce bitmap possède une palette, le traitement ne peut pas fonctionner car Pixels[][], en écriture, ajuste la couleur sur celle qui est la plus proche dans cette même palette.
C'est pour faire quoi au juste ?

J'espère que je ne me suis pas trompé, ni écarté du sujet !

A plus !