Discussion :

[Gilbert Geyer]

Bonjour,

Suite à cette discussion, voici une question en rapport :

Existe-t-il une astuce simple pour tracer une courbe anti-aliasée (???) car avec les MoveTo + LineTo on a plein d'escaliers.

A+.

[Archimède]

En utilisant le GDI mais ce n'est pas simple ...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 xFrm.eM11 :=width/(M*(xmax-xmin));
 xFrm.eM22 :=-height/(M*(ymax-ymin));
 xFrm.eM12 := 0;
 xFrm.eM21 := 0;
//--------------------------------
 xFrm.eDx :=-width*xmin/(xmax-xmin);
 xFrm.eDy :=ymax*height/(ymax-ymin);
//--------------------------------
 SetGraphicsMode(graph.Canvas.Handle, GM_ADVANCED);
 setworldtransform(graph.canvas.handle,xFrm);

Code :

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

const M:integer=1000000;

[Caribensila]

Existe-t-il une astuce simple pour tracer une courbe anti-aliasée.

Je n'ai jamais essayé, mais je pense que le plus rapide serait d'utiliser l'algorithme de tracé de segment de Xiaolin Wu pour joindre les points du tableau.

Algorithme de tracé de segment de Xiaolin Wu avec anti-aliasing

Une implémentation en Delphi (améliorable)

[Gilbert Geyer]

Bonjour,

Merci Caribensila pour le lien je potasserrai à l'occasion.
Pour l'instant je galère pour tracer une ellipse anti-aliasée avec un algo perso mais je galère davantage pour créer l'array de points contigüs notamment dans le cas d'ellipses très aplaties.

A+.

[Charly910]

Bonjour Gilbert,

Retwas semble avoir trouvé la solution dans cette discussion (à laquelle tu avais participé) :

courbe-polybezier

mais peut être que sa solution n'est pas simple à mettre en oeuvre ?

A+

Charly

[Archimède]

Pour vous convaincre sur l'utilisation du GDI, voici un lien ancien tout à fait satisfaisant pour un tracé de courbes :

http://www.developpez.net/forums/d64...mathematiques/

message 12 Franck Soriano

[Gilbert Geyer]

Bonjour,

A Charly910 :

Retwas semble avoir trouvé la solution dans cette discussion (à laquelle tu avais participé) : courbe-polybezier
mais peut être que sa solution n'est pas simple à mettre en oeuvre ?

... Ok merci, j'avais oublié cette discussion.
Par contre pour mon ellipse inclinable je pense être sur la bonne piste, mais faut pas vendre la peau de l'ours avant de l'avoir occis.
Ma question concernait le cas de courbes quelconques et dans ce cas il faut connaître :
- d'une part les points où la tangente à la courbe est soit verticale, soit horizontale, soit inclinée à ± 45°,
- et d'autre part repérer les zones où l'antialias doit être dirigé vers la gauche, le bas, la droite ou le haut.
Pour l'ellipse c'est assez simple mais pour une courbe quelconque ça peut être un casse tête si sa dérivée est trop compliquée et coûte en temps de calcul. Donc avant de me lancer sur ce cas général je guette les bonnes astuces.

A+.

[Montor]

@Gilbert Geyer

pourquoi ignorer les ressource fourni par Archimède

[Archimède]

@Gilbert Geyer

pourquoi ignorer les ressource fourni par Archimède

Merci !

[Gilbert Geyer]

Bonjour,

pourquoi ignorer les ressource fourni par Archimède

Je ne les ignore pas, mais comme je suis en train de peaufiner mon ellipse mon objectif est avant tout de l'achever et je potasserai le cas général plus tard.

A+.

[SNatoon]

• GDI+
  Graphics32 (http://sourceforge.net/projects/grap.../61665/182/137)

[Dr.Who]

J'allais le Dire :

GDI+ (à télécharger sur le site de Mitov, rechercher dans google "gdiplus mitov")

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
 
var
  Bmp : TBitmap;
  AGraphics       : IGPGraphics;
  APen            : IGDIPlus.IGPPen;
  Pts : array of TGPPointF;
begin
  { ... }
  AGraphics := TGPGraphics.Create( Bmp.Canvas );
  AGraphics.SmoothingMode := SmoothingModeAntiAlias;
  // for x := 0 to n do
  //   Pts[x] := MakePointF(.., ..);
  AGraphics.DrawCurveF(TGPPEn.Create( IGDIPlus.ColorRefToARGB($FF00FF), 2.0 ), Pts);
  { ... }
  Canvas.Draw(0,0,Bmp);
end;

[Gilbert Geyer]

Bonjour,

Ok, merci les gars, je viens de télécharger IGDIPlus je ferai des essais demain.
Mais s'il faut en plus utiliser Graphics32 je laisse tomber.

A+.

[Archimède]

Super GDI+...

Un essai sur la courbe à peu de frais...

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
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
133
134
135
136
137
138
139
140
141
 
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs,IGDIPlus;
 
type
 reel=extended;
 
 TReelpoint=record
  x,y:reel;
 end;
 
 Tgraphique=class(Tbitmap)
 private
  xo,yo,xmin,ymin,xmax,ymax,Gx,Gy,taillex,tailley:reel;
  public
  constructor Create(w,h:integer;x1,x2,y1,y2:reel);reintroduce;overload;
  procedure tracerepere(penw:integer;coulpen,clfond:Tcolor);
  procedure tracecourbe(trajectoire:array of TReelpoint);
  Function ptinfo(x,y:reel):TGPPointF;
 end;
 
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormPaint(Sender: TObject);
    procedure FormResize(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Déclarations privées }
    courbe: array of TReelpoint;
    graphique:TGraphique;
  public
    { Déclarations publiques }
  end;
 
function pt(x,y:reel):TReelpoint;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
function pt(x,y:reel):TReelpoint;
begin
 result.x:=x;
 result.y:=y;
end;
 
constructor Tgraphique.Create(w,h:integer;x1,x2,y1,y2:reel);
begin
 inherited create;
 width:=w;
 height:=h;
 xmin:=x1;
 xmax:=x2;
 ymin:=y1;
 ymax:=y2;
 taillex:=xmax-xmin;
 tailley:=ymax-ymin;
 Gx:=width/taillex;
 Gy:=height/tailley;
 xo:=-xmin*Gx;
 yo:=ymax*Gy;
end;
 
procedure TGraphique.tracecourbe(trajectoire:array of TReelPoint);//tracé de la courbe à partir d'un tableau de points en coods mathématiques
var  i:integer;
     traj:array of TGPPointF;
     AGraphics: IGPGraphics;
 
begin
 setlength(traj,length(trajectoire));
 for i:=low(traj) to high(traj) do traj[i]:=ptinfo(trajectoire[i].x,trajectoire[i].y);
 
 AGraphics := TGPGraphics.Create( self.Canvas );
 AGraphics.SmoothingMode := SmoothingModeAntiAlias;
 AGraphics.DrawCurveF(TGPPEn.Create( IGDIPlus.ColorRefToARGB($FF00FF), 2.0 ), traj);
end;
 
Function TGraphique.ptinfo(x,y:reel):TGPPointF;
begin
 result.x:=round(xo+x*Gx);
 result.y:=round(yo-y*Gy);
end;
 
procedure Tgraphique.tracerepere(penw:integer;coulpen,clfond:Tcolor); //tracé des axes
begin
 with canvas do begin
  pen.width:=penw;
  pen.color:=coulpen;
  brush.Color:=clfond;
  fillrect(rect(0,0,width,height));
  moveto(0,round(yo));
  lineto(width,round(yo));
  moveto(round(xo),0);
  lineto(round(xo),height);
 end;
end;
 
 
procedure TForm1.FormCreate(Sender: TObject);
var i:integer;
begin
 position:=poscreencenter;
 clientwidth:=screen.height div 2;
 clientheight:=screen.Height div 2;
 
 setlength(courbe,101);
 for i:= -50 to 50 do courbe[i+50]:= pt(i/10,sin(2*pi*i/50)); //TABLEAU DE POINTS EN COORDS MATHEMATIQUE
 
 end;
 
procedure TForm1.FormPaint(Sender: TObject);
begin
 with graphique do
 begin
  tracerepere(2,0,clwhite);
  tracecourbe(courbe);
 end;
 
 canvas.Draw(0,0,graphique);
end;
 
procedure TForm1.FormResize(Sender: TObject);
begin
  graphique:=TGraphique.Create(clientwidth,clientheight,-5,5,-1.2,1.2); //-5 ...+5  EN ABSCISSE  et -1.2.......1.2 EN ORDONNEE
  invalidate;
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
 graphique.Free;
end;
 
end.

La courbe est nickel...

joindre IGDIPlusAPI.inc et IGDIPlus.pas au dossier contenant le projet...

[Dr.Who]

Héhéhé, je ne vois pas l'interêt d'utiliser Graphics32 si on a GDI+.

GDI+ est super sympa et la version de Mitov (en comparaison à celle de Progidy) est vraiment bien ficelée et traduite.


Un aperçu du resultat :

[Gilbert Geyer]

Bonjour,

A Dr Who :

Héhéhé, je ne vois pas l'interêt d'utiliser Graphics32 si on a GDI+.

... Super ça a l'air chouette je vais essayer ce GDI+, merci beaucoup.

En attendant voici déjà ce que j'ai pu faire avec Delphi-5 standard :
- Une méthode spécifique pour Ellipses (un peu matheuse : Methode A)
- Et une méthode pour Ellipses, Trèfles à 4 feuilles etc qui utilise l'algo Xiaolin Wu pour le maquillage antialias des contours.

Sur ce je vais essayer GDI+.

A+.

[Gilbert Geyer]

Re-bonjour,

Super de super j'ai testé GDI+ avec le code d'Archimède pour commencer : c'est excellent ... merci beaucoup les gars ça a l'air beaucoup plus simple que mon code joint à mon message précédent.

A+.

[Archimède]

Re-bonjour,

Super de super j'ai testé GDI+ avec le code d'Archimède pour commencer : c'est excellent ... merci beaucoup les gars ça a l'air beaucoup plus simple que mon code joint à mon message précédent.

A+.

Oui , c'est remarquable au niveau du résultat et très simple d'utilisation... Je vais approfondir la chose en me faisant une unité spécifique pour les graphes...

Ton code reste somme toute très intéressant (comme d'habitude )


a+

[Dr.Who]

Oui j'adore aussi GDI+ surtout que le GPGraphics peut calquer les canvas, bitmap d'origine.

Par contre un conseil, n'utiliser pas GDI+ sur un canvas d'un composant visible directement !
Passez par un Buffer (TBitmap) ça permet de gagner en performances.

code Template :

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
 
type
  T{name} = class({TCustomControl / TGraphicControl})
  protected
    procedure Paint; override;
  public
    constructor Create(aOwner: {TControl/TWinControl/TComponent}); override;
    destructor Destroy; override;
  end;
 
procedure {Control/Component}.Create;
begin
  Inherited;
 
  fBuffer := TBitmap.Create;
  fBuffer.PixelFormat := pf32bit;
  fBuffer.Width := {ClientWidth / Width / Canvas.ClipRect.Right-Canvas.ClipRect.Left}
  fBuffer.Height := {ClientHeight / Height / Canvas.ClipRect.Bottom-Canvas.ClipRect.Top}
end;
 
procedure {Control/Component}.Destroy;
begin
  fBuffer.Free;
 
  Inherited;
end;
 
procedure {Control/Component}.Resize;
begin
  Inherited;
  fBuffer.Width := {ClientWidth / Width / Canvas.ClipRect.Right-Canvas.ClipRect.Left}
  fBuffer.Height := {ClientHeight / Height / Canvas.ClipRect.Bottom-Canvas.ClipRect.Top}
end;
 
procedure {Control/Component}.Paint;
var 
  GGfx : IGPGraphics;
 // GPen : IGPPen;
 // GBrush: IGPSolidBrush;
 // GFont: IGPFont;
begin
  fBuffer.Canvas.FillRect(fBuffer.Canvas.ClipRect);
 
  GGfx := TGPGraphics.Create(fBuffer.Canvas);
 
  //// GDI & GDI+ here ////
  // GGfx.Draw{...}(...);
 
  Canvas.Draw(0,0,fBuffer);
end;

Je vous remet une petite demo "Bozoon" qui est un Mistify Like fait en GDI+ (Version projet D7), qui utilise la GDIApi de Progdigy (utilisez celle de Mitov dans vos projets bien sur).

[Gilbert Geyer]

Re-salut,

C'est de plus en plus joli : J'apprécie la finesse des traits de la demo "Bozoon".
Par contre va falloir que je potasse comment exploiter les possibilités de GDI+ et avec un Help en anglais c'est assez coton ... mais bon.

A+.