summaryrefslogtreecommitdiff
path: root/info/guide-latex-fr/Chapitres/p3-pstricks.tex
blob: 1d4f14251f1b6de04a188496cf2f18e4fbbe47c5 (plain)
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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
\chapter{Dessiner avec PSTricks}

% Date de la dernière MàJ : 26/02/2019

\label{chap-pstricks}\lettrine{I}{l} n'y a rien de pire que d'apprendre une notion, de l'appréhender, d'expérimenter\dots{} pour se rendre compte qu'une autre est meilleure et qu'il faille tout recommencer depuis le début.

C'est ce qui m'est arrivé avec PSTricks. J'ai appris à dessiner avec ce package, qui requiert de compiler avec le moteur \LaTeX{} ou Xe\LaTeX{}. Puis, j'ai découvert \TikZ{}, qui fonctionne avec n'importe quel moteur de compilation. \\

Je ne vais pas supprimer mon travail initial. Tu peux le consulter. La dernière mise à jour de ce chapitre date du 26 février 2019. Dans tous les cas, \textbf{je te recommande de passer directement au chapitre suivant} sur \TikZ{}.

\section{Fonctionnement général}

Selon le dessin à réaliser, il faut charger un ou plusieurs packages :

\begin{itemize}[label = \ding{213}]
\item \verb?pstricks? : la base pour dessiner avec PSTricks ;

\item \verb?pst-circ? : pour dessiner des circuits électriques ;

\item \verb?pst-node? : pour dessiner des diagrammes ;

\item \verb?pst-eucl? : pour dessiner des figures géométriques ;

\item \verb?pstricks-add? : pour ajouter de nouvelles commandes, comme la rotation d'objets par exemple. \\
\end{itemize}

Ensuite, pour indiquer à \LaTeX{} que nous souhaitons dessiner une image avec PSTricks, il faut utiliser l'environnement \verb?pspicture?, suivi de la taille maximale de l'image au format \verb?(x_max,y_max)?.

Une option supplémentaire, \verb?[showgrid = true]?, est très utile pour visualiser le résultat avec un quadrillage en arrière-plan. Ce dernier permet de corriger des points mal placés ou de faciliter les décalages à faire. \\

Bon, allons faire quelques essais pour mieux saisir le principe de fonctionnement.

\section{Dessiner des circuits électriques}

Le principe de fonctionnement est très simple. Imagine que tu dessines ton circuit électrique sur une feuille de papier. Dans le coin inférieur gauche, tu places un repère et son origine puis tu considères qu'un composant, un fil, etc. revient à se déplacer d'une unité.

Honnêtement, si tu es arrivé jusqu'à cette partie du guide, tu devrais pouvoir aller jeter un coup d'\oe{}il à l'aide du package sans problème, surtout pour avoir accès à toutes les options disponibles. Voici deux petits exemples pour te mettre en bouche :

% Impossible de générer le résultat avec codedisplay ==> utiliser coderesult si insertion souhaité d'un visuel...
\begin{code}{Un cas minimaliste}
\documentclass[a4paper, 12pt]{report}   

% LaTeX // XeLaTeX
\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage[dvipsnames]{xcolor} % Pour les couleurs si besoin
\usepackage{pst-circ} % Pour les circuits électriques


\begin{document}

\everymath{\displaystyle}

\begin{pspicture}[showgrid = true](5,2)
% showgrid affiche le quadrillage
% Permet de se repérer au début et en cas d'erreur
% A mettre sur false lors de la génération du résultat final

% Composants
\resistor(1,1)(2,1){$R$}
% Les coordonnées à renseigner sont celles des extrémités du composant
\coil[dipolestyle = curved](3,1)(4,1){$L$}
	
% Fils
\wire[intensitylabel = $I$, intensitycolor = red, intensitylabelcolor = red](0,1)(1,1)
\wire(2,1)(3,1)
\wire(4,1)(5,1)
	
% Annotations
\tension[labeloffset = -0.5](0.5,0.5)(2.5,0.5){$V$}
% Si coordonnées non entières, utiliser un point
\end{pspicture}

\end{document}
\end{code}

\begin{code}{Un cas plus complet}
\documentclass[a4paper, 12pt]{report}   

% LaTeX // XeLaTeX
\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage[dvipsnames]{xcolor} % Pour les couleurs si besoin
\usepackage{pst-circ} % Pour les circuits électriques


\begin{document}

\everymath{\displaystyle}

\begin{pspicture}[showgrid = true](8,3)
% Composants
\resistor(2,1)(2,2){$R$}
\coil[dipolestyle = curved](4,1)(4,2){$L$} % Un affichage possible pour une bobine
\coil[dipolestyle = elektor](6,3)(7,3){$l$} % Un autre format d'affichage
\resistor(8,1)(8,2){$\frac{r}{g}$}
	
% Fils
\wire[intensitylabel = $I$, intensitylabeloffset = 0.5](0,3)(2,3)
\wire(2,3)(4,3)
\wire[intensitylabel = $I'$](4,3)(6,3)
\wire(7,3)(8,3)
\wire(0,0)(8,0)
\wire(2,0)(2,1)
\wire(2,2)(2,3)
\wire(4,0)(4,1)
\wire(4,2)(4,3)
\wire(8,0)(8,1)
\wire(8,2)(8,3)
	
% Annotations
\tension(0,0)(0,3){$V$}
\end{pspicture}

\end{document}
\end{code}

\begin{conseil}{Conseil personnel}
La génération sous Xe\LaTeX{} peut se révéler assez longue, surtout si tu cumules de nombreux circuits.

Après des essais, le temps d'attente est négligeable avec une compilation sous \LaTeX{}, suivie des conversions d'usage \verb?Dvi -> PS? puis \verb?PS -> PDF?. 

Tu peux donc éventuellement rédiger tout ton rapport avec ce dernier moteur de compilation. Pour rappel, ce dernier ne tolère pas les fichiers \verb?.png? ou \verb?.jpg? pour les images. Il faut donc les convertir en fichier \verb?.eps?, grâce au logiciel \GIMP{} par exemple.
\end{conseil}

\begin{attention}{\textit{Nota Bene}}
Tu as peut-être déjà remarqué que le guide de \verb?pst-circ? utilise une commande \verb?\pnode? pour définir les n\oe{}uds et leur donner une lettre. \\

Il ne s'agit en aucun d'une obligation, comme l'attestent mes précédents exemples. Personnellement, pour un petit schéma, je ne recommande pas de le faire. Je trouve que c'est plus beaucoup plus long s'il faut déplacer des points. 

Cette solution se révèle toutefois plus pratique pour de grands schémas, s'il y a beaucoup de changements à réaliser avant d'obtenir le résultat souhaité et si tu as beaucoup de points communs, par exemple.
\end{attention}

Bon, si tu viens de te rendre compte que \LaTeX{} est extrêmement puissant pour dessiner des circuits d'aussi bonne qualité, sache que ce n'est pas fini. Allons dessiner tout court.

\section{Dessiner tout court}

Pour dessiner avec PSTricks, le principe est extrêmement similaire : tu définis des traits ou des formes à partir de coordonnées et \LaTeX{} trace le tout. C'est parti avec un exemple :

\begin{code}{Un premier dessin : transmission de la chaleur}
\documentclass[a4paper, 12pt]{report}   

% LaTeX // XeLaTeX
\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage[dvipsnames]{xcolor}
\usepackage{pstricks}
% Pas besoin du package xcolor ici
% pstricks l'importe automatiquement


\begin{document}

% Coefficient de transmission thermique d'une paroi
\begin{pspicture}(7,4)
\psline[linecolor = Green](1.5,4)(1.5,0) % Pour tracer une ligne
\psline(2.5,4)(2.5,0)
\psline(3.5,4)(3.5,0)
\psline(4.5,4)(4.5,0)
\psline[linecolor = Green](5.5,4)(5.5,0)
\psline[linecolor = red]{->}(0,2)(7,2)
	
\psframe[fillstyle = hlines](1.5,0)(2.5,4) % Pour tracer un rectangle
\psframe[fillstyle = vlines](3.5,0)(4.5,4)
\psframe[fillstyle = crosshatch](4.5,0)(5.5,4)
	
\rput(2,-0.25){1} % Pour placer une information
\rput(3,-0.25){2}
\rput(4,-0.25){3}
\rput(5,-0.25){4}
\rput(1.5,4.25){\textcolor{Green}{$T_{S_a}$}}
\rput(5.5,4.25){\textcolor{Green}{$T_{S_b}$}}
\rput(7,1.75){\textcolor{red}{$\Phi$}}
\rput(0,3){Ambiance a}
\rput(7,3){Ambiance b}
\rput(0,2.5){$T_a$}
\rput(7,2.5){$T_b$}
\end{pspicture}

\end{document}
\end{code}

\begin{code}{Un second dessin : tracé et hachurage}
\documentclass[a4paper, 12pt]{report}   

% LaTeX // XeLaTeX
\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage{pstricks}
% Pas besoin du package xcolor ici
% pstricks l'importe automatiquement


\begin{document}

% Création d'un domaine hachuré
\begin{pspicture}(7,7)
% Repère
\psline{->}(0,1)(7,1)
\psline{->}(1,0)(1,7)
\uput[d](7,1){$t_A$} % Plus pratique pour placer une indication décalée
% d = down ; u = up ; l = left ; r = right
\uput[ul](1,7){$t_B$} % Combinaison de position possible DANS CET ORDRE (lu ne fonctionne pas)

\pscircle[fillcolor = black, fillstyle = solid](6,1){0.1} % Pour tracer un cercle + le remplir
\uput[d](6,1){30}
	
% Carré et Delta_t (domaine hachuré)
\psline(6,1)(6,6)(1,6)
\pspolygon[linecolor = red, hatchcolor = red, fillstyle = hlines](3,1)(6,4)(6,6)(4,6)(1,3)(1,1)(3,1)
\rput(6.4,6.4){\textcolor{red}{$\Delta_t$}}
	
\pscircle[linecolor = red, fillcolor = red, fillstyle = solid](3,1){0.1}
\rput(3,0.6){\textcolor{red}{$t$}}
\pscircle[linecolor = red, fillcolor = red, fillstyle = solid](1,3){0.1}
\rput(0.6,3){\textcolor{red}{$t$}}	
\end{pspicture}

\end{document}
\end{code}

\begin{conseil}{Pour plus de commandes}
Je ne vois aucun intérêt à faire une liste des commandes et des options possibles. Je t'ai fourni deux exemples pour que tu aies un aperçu du rendu et des possibilités mais à toi d'aller te documenter par la suite. \\

Je te recommande particulièrement d'aller sur : \url{http://fr.wikibooks.org/wiki/LaTeX/Dessiner_avec_LaTeX/Dessiner_avec_PSTricks}. C'est assez complet.
\end{conseil}

\section{Utiliser des coordonnées}

Dans une optique d'automatisation des dessins (un système d'amortisseur en mécanique ou un circuit RLC, utilisés de nombreuses fois, par exemple), il faudrait pouvoir créer une commande.

L'argument principal de cette commande serait alors un point de départ pour le schéma (en bas à gauche, en haut à droite ou ailleurs, au choix). Sous PSTricks, il s'agirait d'un n\oe{}ud (\verb?node?) et tous les autres sont définis à partir de ce n\oe{}ud d'origine (décalage des abscisses et des ordonnées). \\

L'origine sert donc de ``point d'ancrage'' pour positionner le dessin et le reste est construit automatiquement. Pour ce faire, il faut procéder de la manière suivante :

\begin{itemize}[label = \ding{118}]
\item en plus de \verb?pstricks?, charger le package \verb?pst-node? ;

\item définir tous les n\oe{}uds grâce à la commande : \begin{center} \verb?\psnodes(x1,y1){noeud1}..(xN,yN){noeudN}?\end{center}

En l'occurrence, le n{\oe}ud 1 est l'origine ; \verb?(x1,y1)? est donc remplacé par \verb?(#1)? (argument de la commande) ;

\item définir les \verb?(xi,yi)? en commençant par un \verb?!? et selon la méthode NPI (cf. encadré ci-après) ;

\item récupérer les coordonnées selon l'une des deux manières suivantes :

\begin{itemize}[label = \ding{213}]
\item utiliser la commande \verb?\psGetNodeCenter{noeudi} noeudi.Z?, où \verb?Z? correspond à \verb?x? ou \verb?y? (respectivement, récupération de l'abscisse ou de l'ordonnée),

\item \textbf{ou bien,} introduire la commande \verb?saveNodeCoors? dans les options de l'environnement \verb?pspicture? et utiliser ensuite la syntaxe \verb?N-noeudi.Z?. \\
\end{itemize}
\end{itemize}

Il est aussi possible de définir des longueurs pour continuer de généraliser la commande, comme nous le verrons dans l'exemple qui va suivre.

\begin{definition}{La Notation Polonaise Inverse}
{\noindent\huge\bfseries\color{gray!75}\og}

La notation polonaise inverse (NPI) (en anglais RPN pour \textit{Reverse Polish Notation}), également connue sous le nom de notation post-fixée, permet d'écrire de façon non ambiguë les formules arithmétiques sans utiliser de parenthèses.

{\hfill\huge\bfseries\color{gray!75}\fg} \\

\begin{flushright}
Wikipédia -- Disponible sur :

\url{https://fr.wikipedia.org/wiki/Notation_polonaise_inverse}
\end{flushright}

Concrètement, pour utiliser un exemple, l'opération $((1 + 2) \times 4) + 3$ peut être notée en NPI \verb?1 2 + 4 x 3 +?. Il suffit de partir de la gauche, de prendre deux éléments et un opérateur, de faire le calcul et de le remplacer. Pour détailler, nous avons donc ici :

\begin{itemize}[label = \ding{213}]
\item \verb?1 2 + 4 x 3 +? : prendre \verb?1 2 +? qui devient $1 + 2$ soit 3 ;

\item passage à \verb?3 4 x 3 +? : prendre \verb?3 4 x? qui devient $3 \times 4$ soit 12 ;

\item passage à \verb?12 3 +? qui devient $12 + 3$ soit 15. \\
\end{itemize}

Dans le cadre de PSTricks, le fonctionnement est le même sauf que les opérateurs suivants sont utilisés : \verb?add?, \verb?sub?, \verb?mul? et \verb?div?, respectivement pour addition, soustraction, multiplication et division.
\end{definition}

Avec des exemples commentés, nous obtenons des cas d'utilisation possibles :

\begin{code}{Exemple abstrait (boîte)}
% Compiler avec le moteur LaTeX
\documentclass[a4paper, 12pt]{report}

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage[dvipsnames]{xcolor}
\usepackage{pstricks, pst-node, pstricks-add} 
% pst-node pour les noeuds et le calcul de nouvelles coordonnées
% pstricks-add pour la commande \psrotate

\newcommand{\textedbox}[4]{\pnodes(#1){origine}(#2){fin}
\psframe[#3](origine)(fin) 
\rput(!N-fin.x N-origine.x add 2 div N-fin.y N-origine.y add 2 div){\parbox{\linewidth}{\centering{}#4}}}


\begin{document}

\begin{pspicture}[showgrid = true, saveNodeCoors](10,5)
% saveNodeCoors ssi utilisation de N-node_name.x/y
\def\longueur{4 } % Espace OBLIGATOIRE (sinon rien ne s'affiche)
\def\decalage{0.5 }
% Définition de longueurs
% Possibilité de les mettre en argument d'une commande

% Une option brute
\pnodes(1,1){origine}(!\psGetNodeCenter{origine} origine.x 
\longueur add origine.y \longueur add){fin}
\psframe(origine)(fin)
\psline[linecolor = violet]{|<->|}(!N-origine.x N-origine.y 
\decalage sub)(!N-fin.x N-fin.y \longueur \decalage add sub)
% NE PAS écrire \longueur{}...

% Une commande créée avec l'option saveNodeCoors
\rput(4,0){\psrotate(2.5,2.5){90}{\textedbox{0,2}{5,3}{linecolor = red, framearc = 0.5, linestyle = dashed, fillstyle = hlines, hatchcolor = gray}{\textcolor{cyan}{Texte}}}}

% Une autre possibilité	
\rput(9,2.5){\psframebox[linecolor = orange, framesep = 13pt]{\Large{}Test}}
\end{pspicture}

\end{document}
\end{code}

\begin{code}{Exemple concret (amortisseur)}
% Compiler avec le moteur LaTeX
\documentclass[a4paper, 12pt]{report}

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage{amsmath, amsfonts, amssymb}

\usepackage[dvipsnames]{xcolor}
\usepackage{pstricks, pst-node} 
% pst-node pour les noeuds et le calcul de nouvelles coordonnées

\newcommand{\amortisseur}[3]{\pnodes(#1,#2){A}(!#1 1 sub #2){B}(!#1 1 sub #2 1 add){C}(!#1 #2 1 add){D}(!#1 0.5 sub #2 1 add){F}(!#1 0.5 sub #2){E}(!#1 0.5 sub #2 0.5 add){G}(!#1 0.5 add #2 0.5 add){H}(!#1 1 sub #2 0.5 add){I}(!#1 2 sub #2 0.5 add){J}(!#1 0.5 sub #2){K}\psline(A)(B)(C)(D) \psline(F)(E) \psline(G)(H) \psline(I)(J) \uput[d](K){#3}}


\begin{document}

Un cas plus concret avec un amortisseur (taille fixe), moins élégante mais qui fonctionne :

\begin{pspicture}[showgrid = true](3,2)
\amortisseur{2}{0.5}{$\mu$}
\end{pspicture}

\end{document}
\end{code}

Comme tu peux le constater, la définition des n\oe{}uds avec cette méthode est, certes, laborieuse mais peut se révéler très pratique avec la possibilité de créer des commandes : au lieu d'avoir une entrée pour l'abscisse de l'origine et une autre pour son ordonnée, tout passe avec un argument et PSTricks fait le reste.

Autrement, dans la définition des n\oe{}uds, avec cette notation, il ne faut \textbf{pas oublier} le \verb?!? et il est important de noter que la séparation des abscisses et des ordonnées se fait \textbf{SANS} virgule\footnote{Pourquoi ? Je n'en sais rien, ça marche comme ça et c'est très bien. Mais il doit bien y avoir une raison\dots{}}.

\section{Des boîtes pour le texte}

Peut-être l'as-tu remarqué dans mon précédent exemple abstrait mais il est possible de créer des boîtes avec le texte centré, et plein d'autres options. 

Ma commande, définie dans l'exemple précédent, serait ``parfaite'' (de mon point de vue) s'il était possible d'extraire la longueur de la boîte pour l'intégrer comme argument de la \verb?parbox?. Sans succès pour l'instant. 

Mais il semblerait qu'elle fonctionne grâce à un petit \verb?\linewidth?. Tant mieux. \\

Sinon, il existe d'autres possibilités sous PSTricks comme la commande \verb?\PSTextFrame?. Une piste à explorer !

\section{Réaliser des intersections}

Tu as envie de tracer un contour qui correspond à l'intersection de deux cercles mais tu ne sais pas comment faire\dots{} Pas de panique, il existe une solution. Je vais présenter celle disponible sous PSTricks, même s'il en existe une aussi sous \TikZ{} (comme elles portent le même nom, la documentation est facile à trouver).

Il faut réaliser un \verb?clip?. Le fonctionnement est très simple : tu définis la zone d'intersection puis tu places un objet assez grand (comme un rectangle) et paf ! Tu obtiens des Chocapics\dots{} bon ok, quand même pas mais le résultat escompté est là et c'est le plus important.

\begin{code}{Réaliser des intersections}
% Compiler avec le moteur LaTeX
\documentclass[a4paper, 12pt]{report}

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}

\usepackage[dvipsnames]{xcolor}
\usepackage{pstricks}


\begin{document}

\begin{pspicture}[showgrid = true](5,5)
% Chemin de coupure / clip
\psclip{
	\pscircle[linestyle = none](1,2){2}
	\pscircle[linestyle = none](4,2){2}
}
% linestyle = none pour ne pas le dessiner

% Remplir l'intérieur du chemin
\psframe*[linecolor = Cyan](0,0)(4,4) 
\endpsclip{}

% Affichage du contour du chemin de coupure
\pscircle(1,2){2} 
\pscircle(4,2){2}
\end{pspicture}

\vspace{2\baselineskip}

\begin{pspicture}[showgrid = true](5,5)
% Chemin de coupure / clip
\psclip{
	\rput{-30}(0,2){\psframe[linestyle = none](0,0)(3,2)} 
	% psrotate inopérant --> travailler avec rput (partir de (0,0), rotation puis décalage)
	\pscircle[linestyle = none](4,2){2}
}
% Remplir l'intérieur du chemin
\psframe*[linecolor = Cyan](0,0)(4,4)
\endpsclip{}
\end{pspicture}

\end{document}
\end{code}

\section{Extraction du contour d'une image}

Il existe une image, une icône bien spécifique que tu as envie de réexploiter mais elle est trop petite et les pixels sont apparents au moindre zoom. Ou bien tu tiens à la créer toi-même sous \LaTeX{} pour obtenir une image vectorielle\dots{} mais autant passer par un logiciel spécialisé parfois (Photoshop, InDesign, etc.).

Même si le résultat n'est pas encore parfait, il est possible de vectoriser une image, plus particulièrement sur des images monochromes. Le plus dur et le seul point qui nous importe est l'obtention du contour de l'image. Dès que nous avons les coordonnées des points, \verb?\psline? suffit, quitte à ajouter des options pour le remplissage. \\

Par contre, pour réussir à obtenir les coordonnées du contour en question, il faut bidouiller de la manière suivante :

\begin{itemize}[label = \ding{118}]
\item vectoriser l'image sous \Inkscape{}, la lisser si nécessaire (enlever les bosses superflues\dots{}) ;

\item exporter le résultat au format \verb?.tex? (option \verb?Enregistrer sous?) ;

\item ouvrir le code obtenu, vérifier les dimensions utilisées puis épurer le code, c'est-à-dire ne garder que les coordonnées et enlever les commandes s'il y en a ;

\item simplifier les coordonnées (beaucoup de décimales pas forcément utiles, surtout à la vue des dimensions utilisées). Possibilité de laisser ce traitement à un algorithme (proposition d'un algorithme Python ci-après),

\item insérer les coordonnées obtenues dans le code \LaTeX{} final de ton image ;

\item bien reporter les dimensions ou les ajuster si besoin. Par exemple : \begin{center} \verb?\psset{xunit = 0.5pt, yunit = 0.5pt}? \end{center}
\end{itemize}

Normalement, le résultat n'est pas trop moche. Tu peux le lisser sous PSTricks sans effort en utilisant la commande \verb?\pscurve? au lieu de \verb?\psline?. \`A toi de jouer !\footnote{Yu-Gi-Oh oh oh\dots{}}

\begin{code}[listing options = {style = mainlststyle, language = Python, xleftmargin = 17pt, numbers = left, numbersep = 13pt, numberstyle = \ttfamily\footnotesize\color{orange!50!red}, keywordstyle = \color{blue}, stringstyle = \color{orange}}]{Simplifier les coordonnées : un algorithme Python}
def reduction(chaine, nombre) :
    """Réduire la valeur des décimales à "nombre" d'une liste de coordonnées (x,y) (variable chaine)"""
    resultat = ""
    i = 0
    while i <= len(chaine) - 1 : 
        # Coordonnée x
        while chaine[i] != "." : 
        # On implémente et on cherche le point (séparateur des décimales)
            resultat = resultat + chaine[i]
            i = i + 1
        for j in range(0, nombre + 1) : 
        # On implémente la quantité de décimales voulues (nombre)
            resultat = resultat + chaine[i + j]
        i = i + nombre + 1
        while chaine[i] != "," : 
        # On a implémenté le nombre souhaité de décimales 
        # --> aller à l'autre coordonnées
            i = i + 1
        
        # Coordonnée y
        while chaine[i] != "." : # Idem
            resultat = resultat + chaine[i]
            i = i + 1
        for j in range(0, nombre + 1) : # Idem
            resultat = resultat + chaine[i + j]
        i = i + nombre + 1
        while chaine[i] != ")" : # Idem
            i = i + 1
        resultat = resultat + chaine[i]
        i = i + 1
    print(resultat)

chaine = "(13.10458,13.112)(13.10458,13.112)(13.10458,13.112)"
nombre = 2
reduction(chaine, nombre)
\end{code}