[Linux/Windows] Post en forme de tuto à propos de l'exemple Canvas_DrawTest

**Jipété** · 23/06/2018, 10h01

Bonjour,

partant de l'exemple cité en titre, je me suis concentré sur le DrawTest et j'ai fait plein d'essais.

Il en résulte cette image, qui permet en plus de comparer Linux à gauche avec Laz 1.4 et XP à droite avec Laz 1.8.2
Nom : compar_drawtest.jpg
Affichages : 306
Taille : 180,8 Ko

Nom : compar_drawtest.jpg
Affichages : 306
Taille : 180,8 Ko

Ceux qui sont à la pointe de la technologie pourront jouer avec le code ci-après, pour vérifier mes rendus, et c'est très simple :
une fiche de 570 par 620, affecter l'événement OnPaint, y coller ce qui suit :

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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
procedure TfrmDraw.FormPaint(Sender: TObject); // une fiche 570x620
var
  Bmp: TBitmap;
begin
  Bmp := TBitmap.Create;
  Bmp.Width := 50;
  Bmp.Height := 50;
 
  Canvas.CopyMode := cmSrcCopy; // nécessaire sinon dessins pas redessinés si fiche masquée puis démasquée
 
  //Bmp.Canvas.Pen.Width := 6; // = bordure, donc div 2 tout autour, au final
  //Bmp.Canvas.Pen.Color := clRed; // il semblerait que l'utilisation de .Pen
  // en plus de .Brush impacte le rendu de .Rectangle qui n'a plus besoin des -1
  Bmp.Canvas.Pen.Style:=psClear;
//  Bmp.Canvas.Pen.Style:=psInsideFrame;// pratique en tests pour voir où commencent les objets
  // InsideFrame en haut à gauche et OutsideFrame en bas à droite s'il y a la place
 
  Bmp.Canvas.Brush.Color := clRed;
  //                   L, T,  R,   B  -- R et B par rapport au rectangle et PAS W H
  Bmp.Canvas.Rectangle(0, 0, 149, 149);
  // un .Rectangle commence à L et finit à R : si R < à L alors le rectangle "revient sur ses pas"
 
  Bmp.Canvas.Brush.Color := clYellow;
  Bmp.Canvas.FillRect(Rect(13, 0, 149, 149)); // semble identique à dessous
  //Bmp.Canvas.Rectangle(13, 0, 150, 150); // en effet, pas vu de diff.
 
  Bmp.Canvas.Brush.Color := clBlue;
  Bmp.Canvas.Rectangle(5, 10, 30, 20);
 
  Bmp.Canvas.Brush.Color := clMoneyGreen;
  Bmp.Canvas.Rectangle(25, 15,  3, 25); //rect commence à 25 et finit à  3 donc 21 d'occupation
  Bmp.Canvas.Rectangle(25, 30,  3, 35); //rect commence à 25 et finit à  3 donc 21 d'occupation
  Bmp.Canvas.Rectangle( 3, 40, 25, 45); //rect commence à  3 et finit à 25 donc 21 d'occupation
 
  //Canvas.Draw(10,40, Bmp); Exit;
  // fin construction Bmp -- vérifs :
               //       L,  T, R,  B de la dest /!\ /!\
  Canvas.CopyRect(Rect(10,250,60,300), Bmp.Canvas, Bmp.Canvas.ClipRect);
  // Basic, dessiné sous les deux lignes dessinées + bas par BrushCopy
  //Bmp.SaveToFile('c:\bmptest.bmp');
 
  //////////////////////////////////////////////////////////////
  // Tests BrushCopy  //////////////////////////////////////////
  Canvas.Brush.Color := clSkyBlue; // couleur de bg de Canvas.Brushcopy.Dest
 
  // la zone de texte
  Canvas.TextOut(70, 30, 'CopyBrush simple');// L T, le reste s'adapte
 
  // le carré
  //                      position  taille
  // Dest                    L   T   W   H   Src        origine  dim WxL  Transp Color
  // Transp Color = faux nom --> Zone transparente repérée par la couleur donnée
  // parce que dans le Bmp le bleu est sur le jaune qui est sur le rouge
  // mon gars, arrête de voir des couleurs empilées, elles sont côte à côte dans le Bmp.
  Canvas.BrushCopy(Bounds(  10, 50, 50, 50), Bmp, Bounds( 0,  0, 50, 50), clNone);
  Canvas.BrushCopy(Bounds(  70, 50, 50, 30), Bmp, Bounds( 0,  0, 50, 50), clBlue);
  Canvas.BrushCopy(Bounds( 130, 50, 50, 40), Bmp, Bounds( 0,  0, 50, 50), clRed);
  Canvas.BrushCopy(Bounds( 190, 50, 50, 50), Bmp, Bounds( 0,  0, 50, 50), clYellow);
  Canvas.BrushCopy(Bounds( 250, 50, 50, 50), Bmp, Bounds(10, 10, 30, 20), clYellow);
  Canvas.BrushCopy(Bounds( 310, 50, 50, 50), Bmp, Bounds(10, 20, 30, 20), clNone);// A 5-45
  Canvas.BrushCopy(Bounds( 370, 50, 50, 50), Bmp, Bounds(10, 20, 15, 25), clNone);// B 10-40
  Canvas.BrushCopy(Bounds( 430, 50, 50, 50), Bmp, Bounds(00, 00, 15, 50), clNone);// C
  Canvas.BrushCopy(Bounds( 490, 50, 50, 50), Bmp, Bounds(02, 00, 12, 50), clNone);// D 4-42-4
 
  Canvas.BrushCopy(Bounds( 10, 150, 25, 35), Bmp, Bounds(02, 00, 12, 50), clNone);// E
  Canvas.BrushCopy(Bounds( 70, 150, 25, 35), Bmp, Bounds(00, 00, 50, 50), clNone);//
  Canvas.BrushCopy(Bounds(130, 150, 25, 50), Bmp, Bounds(00, 00, 50, 20), clNone);//
  Canvas.BrushCopy(Bounds(190, 150, 20, 20), Bmp, Bounds(00, 00, 50, 50), clNone);// floue
  Canvas.BrushCopy(Bounds(250, 150, 20, 20), Bmp, Bounds(00, 00, 50, 50), clBlue);// floue
  Canvas.BrushCopy(Bounds(310, 150, 20, 20), Bmp, Bounds(00, 00, 20, 20), clNone);// nette
  Canvas.BrushCopy(Bounds(370, 150, 20, 20), Bmp, Bounds(00, 00, 20, 20), clBlue);// nette
  // la Dest est remplie avec la nouvelle couleur de Brush
  // et la transparence s'applique à la Dest
  // Bounds Src : si on ne prend pas tout, ça génère des zones noires -- pas reproduit
  // A : on commence à 10 et on prend 30 qu'on agrandit à 50 : ça donne  5-45
  // B : on commence à 10 et on prend 15 qu'on agrandit à 50 : ça donne 10-40
  // C : on commence à  0 et on prend 15 qu'on agrandit à 50 : ça donne 10-33-7
  // D: je démarre à 2 (sur 3) et j'en prends 12, soit 1R+10B+1J --> 4-42-4
  // E: le fait de demander W 25 en dest --> on dirait que la source est comprimée
  // à CONFIRMER !!!
 
  {  Makes a stretch draw operation while substituting a color of the source bitmap
  with the color of the brush of the canvas }
  Canvas.Brush.Color := clPurple; // va remplacer la couleur repérée par Transp Color
  Canvas.BrushCopy(Bounds(  70, 250, 50, 50), Bmp, Bounds( 0,  0, 50, 50), clBlue);
  Canvas.Brush.Color := clNone; // = blanc
  Canvas.BrushCopy(Bounds( 130, 250, 50, 50), Bmp, Bounds( 0,  0, 50, 50), clBlue);
 
  // les 2 autres textes de l'exemple d'origine
  //  Canvas.Brush.Color := clYellow;// orig
  Canvas.Brush.Color := clRed; // remonté ici
  Canvas.TextOut(200, 230, 'CopyBrush stretch');// L T
  Canvas.BrushCopy(Bounds(200, 250, 20, 20), Bmp, Bounds(0, 0, 50, 50), clBlue);// orig
  // --> Bmp d'origine stretched en 20x20
  //Canvas.BrushCopy(Bounds(200, 250, 20, 20), Bmp, Bounds(0, 0, 10, 10), clBlue);
 
  //Canvas.Brush.Color := clGreen; // remonté ici
  Canvas.Brush.Color := clYellow;// orig
  Canvas.TextOut(350, 230, 'CopyBrush SrcRect');// L T
  //Canvas.BrushCopy(Bounds(350, 250, 20, 20), Bmp, Bounds(30, 30, 20, 20), clBlue);// orig
  // petite image toute jaune : on commence à 30,30, on prend 20x20 c'est tout jaune
  Canvas.BrushCopy(Bounds(350, 250, 20, 20), Bmp, Bounds(5, 5, 20, 20), clBlue);
  // on commence à 5,5, on prend 20x20 et le clBlue est remplacé par Brush.Color
  // copie 1/1 de la partie choisie
//exit;
 
 
  // CopyMode line 1
 
  Canvas.TextOut(50, 330, 'cmBlackness');
  Canvas.CopyMode := cmBlackness;
  Canvas.Draw(50, 350, Bmp);
 
  Canvas.TextOut(150, 330, 'cmDstInvert');
  Canvas.CopyMode := cmDstInvert;
  Canvas.Draw(150, 350, Bmp);
 
  Canvas.TextOut(250, 330, 'cmMergeCopy');
  Canvas.CopyMode := cmMergeCopy;
  Canvas.Draw(250, 350, Bmp);
 
  Canvas.TextOut(350, 330, 'cmMergePaint');
  Canvas.CopyMode := cmMergePaint;
  Canvas.Draw(350, 350, Bmp);
 
  Canvas.TextOut(450, 330, 'cmNotSrcCopy');
  Canvas.CopyMode := cmNotSrcCopy;
  Canvas.Draw(450, 350, Bmp);
 
  // CopyMode line 2
 
  Canvas.TextOut(50, 430, 'cmNotSrcErase');
  Canvas.CopyMode := cmNotSrcErase;
  Canvas.Draw(50, 450, Bmp);
 
  Canvas.TextOut(150, 430, 'cmPatCopy');
  Canvas.CopyMode := cmPatCopy;
  Canvas.Draw(150, 450, Bmp);
 
  Canvas.TextOut(250, 430, 'cmPatInvert');
  Canvas.CopyMode := cmPatInvert;
  Canvas.Draw(250, 450, Bmp);
 
  Canvas.TextOut(350, 430, 'cmPatPaint');
  Canvas.CopyMode := cmPatPaint;
  Canvas.Draw(350, 450, Bmp);
 
  Canvas.TextOut(450, 430, 'cmSrcAnd');
  Canvas.CopyMode := cmSrcAnd;
  Canvas.Draw(450, 450, Bmp);
 
  // CopyMode line 3
 
  Canvas.TextOut(50, 530, 'cmSrcCopy');
  Canvas.CopyMode := cmSrcCopy;
  Canvas.Draw(50, 550, Bmp);
 
  Canvas.TextOut(150, 530, 'cmSrcErase');
  Canvas.CopyMode := cmSrcErase;
  Canvas.Draw(150, 550, Bmp);
 
  Canvas.TextOut(250, 530, 'cmSrcInvert');
  Canvas.CopyMode := cmSrcInvert;
  Canvas.Draw(250, 550, Bmp);
 
  Canvas.TextOut(350, 530, 'cmSrcPaint');
  Canvas.CopyMode := cmSrcPaint;
  Canvas.Draw(350, 550, Bmp);
 
  Canvas.TextOut(450, 530, 'cmWhiteness');
  Canvas.CopyMode := cmWhiteness;
  Canvas.Draw(450, 550, Bmp);
 
  Bmp.Free;
end;

F9 et ouvrir ses yeux tout en lisant le code et ses commentaires.
Puis "s'approprier" le code et pour ça, une seule manière, modifier un paramètre (une couleur, une dimension), F9 et comparer avec avant.

Ensuite, en se concentrant sur la partie basse, les trois lignes reprennent l'exemple de base sans traficotages et heureusement que j'ai une loupe quand je bidouille ce genre de choses, ça m'a permis de découvrir des rendus à la limite de la visibilité, qui apparaîssent mieux en éclaircissant ou assombrissant les couleurs et, franchement, je ne sais pas trop à quoi ça peut servir ni comment l'utiliser, surtout qu'il y a des différences entre les OS...
Nom : forcer_couleurs.jpg
Affichages : 260
Taille : 123,0 Ko

Nom : forcer_couleurs.jpg
Affichages : 260
Taille : 123,0 Ko

En haut l'original copié/collé depuis le bas de l'image précédente, au milieu la même chose mais éclaircie et en bas assombrie, et on remarque que certaines couleurs quasiment invisibles "montent" (on se croirait dans un labo photo à l'époque des agrandisseurs, si vous avez connu).
Comparez les 3^es lignes : ce qui est (donc à la limite du) blanc ou noir dans l'original devient visible.

Note : il n'y a que les 4 premières colonnes, la 5^e à droite toute n'apportant rien.

Voilà,

**BeanzMaster** · 23/06/2018, 10h51

(Re)Salut

Certain rendu me paraisse carrément à coté de la plaque, mais c'est peut-être moi. C'est pour ça que j'évite au maximum d'utilisé les TBitmap et ce genre de fonctions dans le "Canvas" je me cantonne aux basiques : ligne, cercle, rectangle,... Draw et StretchDraw à part ça le reste j'ai abandonné. Je préfère utilisé des trucs dans le genre de mon projet et de l'unité uFastBitmap présent dans le GIFViewer

et au moins j'ai un contrôle total dessus.

**Jipété** · 23/06/2018, 15h46

Envoyé par BeanzMaster

Certains rendus me paraissent carrément à côté de la plaque, mais c'est peut-être moi.

Ceux du milieu et du bas de la deuxième image ?
Si oui c'est normal, puisque j'ai forcé l'éclaircissement et l'assombrissement pour visualiser des teintes à peine discernables à la loupe.
Ces forçages impactent tout, je sais bien, je les ai utilisés juste pour montrer que ce que qu'on voit à la va-vite comme noir ou comme blanc ne l'est pas toujours.

EDIT : j'ai repris cette grande image pleine de lignes, et j'en ai généré 3 petites, pour comparer ligne par ligne, donc dans chaque image de haut en bas le rendu normal, de base, puis le même mais éclairci et en bas le même assombri :
1^re ligne, Linux à gauche XP à droite :
Nom : forcer_couleurs_1re_ligne.jpg
Affichages : 217
Taille : 41,5 Ko

Nom : forcer_couleurs_1re_ligne.jpg
Affichages : 217
Taille : 41,5 Ko

2^e ligne :
Nom : forcer_couleurs_2e_ligne.jpg
Affichages : 219
Taille : 46,3 Ko

3^e ligne :
Nom : forcer_couleurs_3e_ligne.jpg
Affichages : 263
Taille : 45,2 Ko

Si non, alors précise ta pensée.

**BeanzMaster** · 23/06/2018, 16h31

Ok, mais par exemple le cmMergeCopy quel est le bon rendu ? Linux ou XP ?
Pour lrs cmPat???? on voit bien que ça cloche les rendus sont carrément différent entre les 2 OS.
Ensuite les cmSrcCopy et cmSrcPaint c'est quoi cette différence par rapport à ces 2 nom de variables il me semblerai logique d'obtenir les mêmes rendus.

Petites questions "Source" c'est ton image pleine de lignes ? Ta destination est un fond noir ?

**Jipété** · 23/06/2018, 16h39

Envoyé par BeanzMaster

Ok, mais par exemple le cmMergeCopy quel est le bon rendu ? Linux ou XP ?
Pour lrs cmPat???? on voit bien que ça cloche les rendus sont carrément différent entre les 2 OS.
Ensuite les cmSrcCopy et cmSrcPaint c'est quoi cette différence par rapport à ces 2 nom de variables il me semblerai logique d'obtenir les mêmes rendus.

Je ne sais pas quoi t'en dire : je constate comme toi. Je susi simplement parti de l'exemple trouvé dans le dossier examples et en ai fait le code que tu as vu...

Envoyé par BeanzMaster

Petites questions "Source" c'est ton image pleine de lignes ?

Oui, c'est le TBitmap Bmp, rempli au fur et à mesure.

Envoyé par BeanzMaster

Ta destination est un fond noir ?

Non, c'est le Canvas de la fiche.

**Jipété** · 26/06/2018, 19h00

Bonjour,

Toujours dans mes tests, je trouvais que j'avais parfois des résultats curieux, alors j'ai fait des recherches sur le mot "CopyMode" et je suis d'abord tombé sur la définition d'Embarcadero (c'est du Delphi, pour ceux qui ne connaîtraient pas), qui dit ça (l'aide de Lazarus ne dit rien, comme ça ils ne risquent pas de se tromper...) :

Envoyé par embarcadero

The CopyMode property is used by the CopyRect routine when copying an image from another canvas onto the current canvas.

Est-ce que ça veut dire que Canvas.BrushCopy n'est pas concerné ? Ni Canvas.Draw ?
Ennuyeux de ne pas avoir une certitude là-dessus, car s'il faut aller tout vérifier, le coding ne va pas avancer vite.

Ensuite, je me suis livré à une expérimentation décourageante en partant de CopyRect et CopyMode avec sa quinzaine de possibilités, qu'on peut retrouver là.

Il en ressort ça, avec à gauche Linux, à droite XP, les deux sous Laz 1.8.2 pour une fois !, et de haut en bas :

le mode "départ", aucune action de CopyRect n'a été demandée
CopyRect avec le paramètre MergeCopy
CopyRect avec le paramètre PatCopy
CopyRect avec le paramètre PatInvert
CopyRect avec le paramètre PatPaint

Nom : copymode_linux_xp.png
Affichages : 229
Taille : 50,0 Ko

(images réduites de moitié)
Les autres paramètres génèrent des résultats identiques, ouf !

Je suis parti du code sympathique trouvé dans ce pdf, pages 76 et suivantes, ce qu'il y a de bien c'est qu'il y a 3 images (dommage, pas en couleurs), ça permet de vérifier qu'on obtient les résultats attendus -- sauf moi et mon os exotique...

**Jipété** · 26/06/2018, 23h54

Envoyé par Jipété

Est-ce que ça veut dire que Canvas.BrushCopy n'est pas concerné ? Ni Canvas.Draw ?
Ennuyeux de ne pas avoir une certitude là-dessus, car s'il faut aller tout vérifier, le coding ne va pas avancer vite.

Pour Draw et StretchDraw, embarcadero dit :

If the graphic is a TBitmap object, the bitmap is rendered using the value of CopyMode.

Pour BrushCopy je n'ai pas encore trouvé la réponse, mais dans le code de la procédure (dans canvas.inc) on trouve un appel à Draw et un autre à StretchDraw.

Juste bien penser à initialiser la valeur de CopyMode avant l'appel, sinon on peut facilement se faire avoir.
Voir l'exemple "cut" tout en bas de cette page.

[Linux/Windows] Post en forme de tuto à propos de l'exemple Canvas_DrawTest

Lazarus Pascal

Discussions similaires

Partager

Partager