image en forme de cercle

Version imprimable

06/10/2005, 14h31
mathieu57

image en forme de cercle

bonjour,
j'aimerai savoir comment faire appraitre une image seulement dans un cercle, la partie de l'image hors du cercle n'apparaitrait pas.
j'ai essayé avec un composant Timage et un Tshape en forme de cercle, mais ca ne donne pas ce que je veux.
merci d'avance pour vos réponses.
06/10/2005, 15h14
Patrick Seuret

Modifie dans un programme de dessin ton image pour ne faire apparaître que la partie qui 'intéresse dans le cercle et tout le reste (l'extérieur) dans une seule couleur.

Ensuite, tu mets l'image dans un TImage avec la propriété Transparent à true.

Sauf erreur de ma part, c'est la couleur du point en bas à droite de l'image qui est utilisé pour définir la couleur transparente.
06/10/2005, 15h15
mathieu57

merci pour la réponse, mais c'est l'utilisateur de l'appli qui inserera une image au moyen d'un bouton style 'Parcourir', donc je ne peux pas faire ta manip à l'avance...

Vous pouvez le calculer vous-même. Vous chargez une image, dans un autre bitmap vous dessinez une ellipse en blanc sur noir par exemple, puis en analysant l'autre bitmap vous décidez ou non de recopier l'image d'origine.

On fait l'analyse ligne à ligne, on déclare la fonction dans la classe principale :

Code:

void AnalyseLigne(int, Graphics::TBitmap*, Graphics::TBitmap*,int);

Mettez un composant TImage sur la forme et un bouton. Sur clic du bouton le calcul se déclenche :
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 void __fastcall TForm1::Button1Click(TObject *Sender) { int w,h,i; Graphics::TBitmap *b1, *b2; b1=new Graphics::TBitmap(); b1->LoadFromFile("image.bmp"); w=b1->Width; h=b1->Height; b2=new Graphics::TBitmap(); b2->Width=w; b2->Height=h; b2->PixelFormat=pf24bit; b2->Canvas->Brush->Color=clBlack; b2->Canvas->FillRect(Rect(0,0,b2->Width,b2->Height)); b2->Canvas->Pen->Color=clWhite; b2->Canvas->Ellipse(0, 0, b2->Width, b2->Height); for(i=0;i<h;i++) AnalyseLigne(i,b1,b2,h); Image1->Width=w; Image1->Height=h; Image1->Picture->Assign(b2); delete b1; delete b2; }
Et on analyse ainsi une ligne en cherchant le blanc de l'ellipse et en décidant ou non de recopier l'original :
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 void TForm1::AnalyseLigne(int l, Graphics::TBitmap* b1, Graphics::TBitmap* b2, int h) { int i; BYTE *Lig1, *Lig2; Lig1 = (BYTE*)b1->ScanLine[l]; Lig2 = (BYTE*)b2->ScanLine[l]; i=0; while(Lig2[i]==clBlack) i+=3; while(Lig2[i]!=clBlack) { Lig2[i]=Lig1[i]; Lig2[i+1]=Lig1[i+1]; Lig2[i+2]=Lig1[i+2]; i+=3; } if(l!=0 && l!=h) { while(Lig2[i]==clBlack) { Lig2[i]=Lig1[i]; Lig2[i+1]=Lig1[i+1]; Lig2[i+2]=Lig1[i+2]; i+=3; } while(Lig2[i]!=clBlack) { Lig2[i]=Lig1[i]; Lig2[i+1]=Lig1[i+1]; Lig2[i+2]=Lig1[i+2]; i+=3; } } }
Il y a peut-être mieux, un truc automatique avec couleur transparente par exemple, mais je n'en sais rien. Par défaut, je programme les choses "à la main" étant donné qu'on est jamais mieux servi que par soi-même.

À bientôt
Gilles

07/10/2005, 09h16
Patrick Seuret

C'est une bonne idée :-)

Pour aller peut-être un peu plus vite, on peut aussi dessiner une ellipse pleine en blanc (0x00FFFFFF) sur un fond noir (0x00000000) et faire des AND logique entre les deux images. Cela met automatiquement tout le pourtour en noir...

Ler problème est que si votre image contient du noir et que c'est la couleur transparente, alors ces parties deviendront transparente aussi... Solution: afficher dessous la même ellipse mais en noir sur fond blanc avec le blanc transparent... Ouf!

Sinon il est peut-être possible de dessiner directement la bitmap grace au GDI de Windows (voir les fonctions "Binary Raster Operations" du "Windows GDI" dans l'aide MSDN). Mais cela sort de mes compétences...
07/10/2005, 09h34
Patrick Seuret

Il y a aussi la fonction StretchDIBits qui permet de dessiner directement une image à l'écran avec une transparence (voir le paramètre dwRop) si l'image n'est pas directement un JPEG ou un PNG

Pour dwRop, voir à nouveau le raster operation (ROP)

Salut !

Voici une petit exemple avec une class dérivée de TCustomControl.
J'ai exploité les actions de la souris pour faire glisser l'image dans le cercle.
On peut sans doute optimiser/simplifier (pour ceux qui ont le temps...).

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
class TCercle : public TCustomControl
{
private :
Graphics::TBitmap *Bitmap;
Graphics::TBitmap *Source;
int Ofx;
int Ofy;
bool Flag;
int Movx;
int Movy;
        void __fastcall SetWidth(int Value);
        void __fastcall SetHeight(int Value);
        int __fastcall GetWidth();
        int __fastcall GetHeight();
 
public :
Graphics::TBitmap *Image;
 
    __fastcall TCercle(TComponent *Owner, Graphics::TBitmap *I);
    __fastcall ~TCercle();
    void __fastcall Paint();
//Evénements de la souris
    void __fastcall CercleMouseDown(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y);
    void __fastcall CercleMouseMove(TObject *Sender, TShiftState Shift,
          int X, int Y);
    void __fastcall CercleMouseUp(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y);
 
//Ici je surcharge les propriétés pour pouvoir ajuster automatiquement
//celles des bitmaps utilisés lorsqu'elles sont modififiées.
    __property int Width = {read=GetWidth, write=SetWidth};
    __property int Height = {read=GetHeight, write=SetHeight};
};

Les méthodes de la class :

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
__fastcall TCercle::TCercle(TComponent *Owner, Graphics::TBitmap *I)
    : TCustomControl(Owner)
{
if(Owner->InheritsFrom(__classid(TWinControl)))
    {
    Parent = (TWinControl*)Owner;
    }
Bitmap = new Graphics::TBitmap;
Bitmap->PixelFormat = pf24bit;
Source = new Graphics::TBitmap;
Source->PixelFormat = pf24bit;
Image = I;
Ofx = 0; Ofy = 0;
Flag = false;
OnMouseDown = CercleMouseDown;
OnMouseMove = CercleMouseMove;
OnMouseUp  = CercleMouseUp;
}
//------
__fastcall TCercle::~TCercle()
{
delete Bitmap;
delete Source;
}
//------
void __fastcall TCercle::SetWidth(int Value)
{
TCustomControl::Width = Value;
Bitmap->Width = Value;
Source->Width = Value;
}
//------
void __fastcall TCercle::SetHeight(int Value)
{
TCustomControl::Height = Value;
Bitmap->Height = Value;
Source->Height = Value;
}
//------
int __fastcall TCercle::GetWidth()
{
return TCustomControl::Width;
}
//------
int __fastcall TCercle::GetHeight()
{
return TCustomControl::Height;
}
//------
void __fastcall TCercle::Paint()
{
//Effacer le bitmap qui va être affiché
TCanvas *B = Bitmap->Canvas;
B->Pen->Color = clSilver; //couleur de fond de la form
B->Pen->Style = psSolid;
B->Pen->Mode = pmCopy;
B->Brush->Color = clSilver;
B->Brush->Style = bsSolid;
B->Rectangle(0,0,Width, Height);
 
//Effacer le bitmap intermédiaire
TCanvas *S = Source->Canvas;
S->Pen->Color = clBlack;
S->Pen->Style = psSolid;
S->Pen->Mode = pmCopy;
S->Brush->Color = clBlack;
S->Brush->Style = bsSolid;
S->Rectangle(0, 0, Width, Height);
 
//Copier une zone de l'image dans le bitmap intermédiaire
TRect Dest = Rect(0, 0, Source->Width, Source->Height);
TRect Srce = Rect(Ofx, Ofy, Ofx + Source->Width, Ofy + Source->Height);
S->CopyRect(Dest, Image->Canvas, Srce);
 
//Copier les pixels qui appartiennent au cercle
Byte *pS;
Byte *pB;
double r = Width  / 2;
int xe;
int ye;
/*
Le raisonnement porte ici sur un cercle.
Ce serait intéressant de développer pour une ellipse (le cercle n'étant qu'un cas 
particulier... Mais je ne connais pas la formule !)
*/
for(int y = -r; y < r; y++)
    {
    ye = y + r;
    pS = (Byte*)Source->ScanLine[ye];
    pB = (Byte*)Bitmap->ScanLine[ye];
    for(int x = -r; x < r; x++)
        {
        if(hypot(x, y) < r) 
            {
            xe = (x + r) * 3;
            pB[xe] = pS[xe]; xe++;
            pB[xe] = pS[xe]; xe++;
            pB[xe] = pS[xe];
            }
        }
    }
Canvas->Draw(0,0,Bitmap);
}
//------
void __fastcall TCercle::CercleMouseDown(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y)
{
double r = Width / 2;
if(hypot(X - r, Y - r) < r)
    {
    Movx = X; Movy = Y; Flag = true;
    }
}
//------
void __fastcall TCercle::CercleMouseMove(TObject *Sender, TShiftState Shift,
          int X, int Y)
{
if(Flag)
    {
    Ofx = Ofx + Movx - X;
    Ofy = Ofy + Movy - Y;
    Movx = X; Movy = Y;
    Paint();
    }
}
//------
void __fastcall TCercle::CercleMouseUp(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y)
{
Flag = false;
}

Voici comment j'ai utilisé cette class :

Déclarations globales :

Code:

1
2
3
4
TCercle *Cercle;
Graphics::TBitmap *Image = new Graphics::TBitmap;
AnsiString Filepath;
AnsiString Filename;

Dans le constructeur de la form :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
Filepath = ExtractFilePath(Application->ExeName);
Filename = Filepath + "Photo.bmp";
if(FileExists(Filename))
    {
    Image->LoadFromFile(Filename);
    Image->PixelFormat = pf24bit;
    }
Cercle = new TCercle(this, Image);
Cercle->Top = 20;
Cercle->Left = 20;
Cercle->Width = 100;
Cercle->Height = 100;
Cercle->Visible = true;
}

A plus !