Création d'un cercle

Version imprimable

12/04/2007, 14h44
bahiatoon

Création d'un disque

:salut:

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;)
12/04/2007, 16h07
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
12/04/2007, 22h12
yarp

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

Yarp
14/04/2007, 18h13
bahiatoon

1 pièce(s) jointe(s)

:salut:

Je me suis mal expliqué dans mon dernier message :oops:,

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

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

A+
14/04/2007, 18h39
blondelle

Salut bahiatoon:
Peut etre en utilisant la fonction Ellipse ;)
14/04/2007, 19h35
bahiatoon

:salut:

Citation:

Peut etre en utilisant la fonction Ellipse

STP, peux tu me donner un exemple de code

A+
14/04/2007, 19h53
blondelle

Tire de l'aide en ligne.

Citation:

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

Citation:

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

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:

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 !

15/04/2007, 14h35
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.
15/04/2007, 15h36
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 !
15/04/2007, 17h07
Mat.M

Citation:

Envoyé par bahiatoon

:salut:

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
15/04/2007, 18h14
Neilos

Ouais mais TCanvas::Ellipse sait le faire....
15/04/2007, 18h25
bahiatoon

:salut:

MERCI pour vos réponses:king:

Citation:

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+
15/04/2007, 18h28
Neilos

Tu entends quoi par faire passer pixel par pixel ?
Le dessiner ?
Quel est l'intérêt de tout ça au final ?
15/04/2007, 19h33
henderson

Salut !

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

A plus !
15/04/2007, 21h45
bahiatoon

:salut:

Citation:

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.

Citation:

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+
15/04/2007, 22h05
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...
15/04/2007, 23h22
henderson

Salut !

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

Code:

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 !

Salut,

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

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

Voici le code pour un rayon=10:

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
 
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+

Salut !

Pour les nivaux de gris :

Code:

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:

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:

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 !

Salut,

je ne parviens toujours pas à cerner le problème:bug: :aie:

j'ai pris un exemple simple ou le rayon=1 ,j'ai utilisé le code suivant:

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
 
int tri[1000];
 
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);
        }
int max;
 
for(int x = 0; x < W; x++)
    for(int y = 0; y < H; y++)
       {
        tri[1]=Image[x-1][y];
        tri[2]=Image[x+1][y];
        tri[3]=Image[x][y+1];
        tri[4]=Image[x][y-1];
        max=tri[1];
        for(int i=2;i<=4;i++){if (max<tri[i]) max=tri[i];}
 
image[x][y]=max;
        }
 
 
for(int x=0;x<W;x++)
        for(int y=0;y<H;y++)
        {
        Image1->Canvas->Pixels[x][y]=(TColor)((int)(image[x][y]+256*image[x][y]+256*256*image[x][y]));
        }

et avec ce code j'obtiens le résultat voulu :P , mais dès que je généralise(rayon quelconque)ça ne marche plus:cry: :cry: :cry:

Citation:

henderson à écrit:
C'est pour faire quoi au juste ?

c'est une érosion de l'image.

A+

Salut,

Enfin, le programme est fonctionnel:yaisse2:

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
 
int tri[1000];
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);
        }
 
int px, py;
double d;
int max;
for(int x = 0; x < W; x++)
    for(int y = 0; y < H; y++)
       {
        int k=1;
        for (int i = -50; i <= +50; i++)
                {
                px = x + i;
                for(int j = -50; j <= +50; j++)
                                {
                                py = y + j;
                                if((px >= 0) && (px < W) && (py >= 0) && (py < W))
                                        {
                                         //d = hypot(px,py);
                                        d=sqrt(pow(x-px,2)+pow(y-py,2));
                                        if (d <= 50.0)
                                                {
                                                tri[k]=Image[px][py];
                                                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=0;x<W;x++)
    for(int y=0;y<H;y++)
    {
    Image1->Canvas->Pixels[x][y]=(TColor)((int)(image[x][y]+256*image[x][y]+256*256*image[x][y]));
    }
}

Merci beaucoup pour votre aide:king:

17/04/2007, 20h55
henderson

Salut !

Chez moi aussi ça fonctionne bien !

Par contre, pourquoi ne pas utiliser : d = hypot(i,j) ?
A t-on un avantage à utiliser le sqrt (pow pow) ?

Et pourquoi ne pas réaliser le max directement au lieu d'avoir un boucle supplémentaire ?

Enfin... l'essentiel est que ça tourne !

A plus et bon courage pour la suite !
17/04/2007, 22h57
bahiatoon

Salut,

Citation:

Par contre, pourquoi ne pas utiliser : d = hypot(i,j) ?
A t-on un avantage à utiliser le sqrt (pow pow) ?

il n'y a aucun avantage à utiliser le sqrt (pow pow), c'est seulement une question d'habitude:mrgreen:

A bientôt;)