%! % PostScript prologue for pst-solides3d.tex. % Version 4.01, 2008/07/09 % %% COPYRIGHT 2008 by Jean-Paul Vignault %% %% This program can be redistributed and/or modified under the terms %% of the LaTeX Project Public License Distributed from CTAN %% archives in directory macros/latex/base/lppl.txt. % /SolidesDict 100 dict def /SolidesbisDict 100 dict def SolidesDict begin %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% %% les variables globales gerees par PSTricks %% %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% %% les lignes dessous sont a decommenter si l on veut utiliser le %% %% fichier solides.pro independamment du package PSTricks %% /Dobs 20 def %% /THETA 20 def %% /PHI 50 def %% /Decran 30 def %% /XpointVue {Dobs Cos1Cos2 mul} def %% /YpointVue {Dobs Sin1Cos2 mul} def %% /ZpointVue {Dobs Sin2 mul} def %% /xunit 28.14 def %% /solidhollow false def %% /solidbiface false def %% /xunit 28.45 def %% /tracelignedeniveau? true def %% /hauteurlignedeniveau 1 def %% /couleurlignedeniveau {rouge} def %% /linewidthlignedeniveau 4 def %% /solidgrid true def /aretescachees true def /defaultsolidmode 2 def %% variables globales specifiques a PSTricks %% /activationgestioncouleurs true def /xmin -10 def /xmax 10 def /ymin -10 def /ymax 10 def /fillstyle {} def /startest false def /cm {} def /cm_1 {} def /yunit {xunit} def /angle_repere 90 def /hadjust 2.5 def /vadjust 2.5 def /pl@n-en-cours false def /pointilles { [6.25 3.75] 1.25 setdash } def /stockcurrentcpath {} def /newarrowpath {} def /chaine 15 string def %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% choix d une fonte accentuee pour le .ps %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /ReEncode { exch findfont dup length dict begin { 1 index /FID eq {pop pop} {def} ifelse }forall /Encoding ISOLatin1Encoding def currentdict end definefont pop }bind def /Font /Times-Roman /ISOfont ReEncode /ISOfont def %Font findfont 10 scalefont setfont %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% extrait de color.pro pour pouvoir recuperer ses couleurs %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /GreenYellow{0.15 0 0.69 0 setcmykcolor}def /Yellow{0 0 1 0 setcmykcolor}def /Goldenrod{0 0.10 0.84 0 setcmykcolor}def /Dandelion{0 0.29 0.84 0 setcmykcolor}def /Apricot{0 0.32 0.52 0 setcmykcolor}def /Peach{0 0.50 0.70 0 setcmykcolor}def /Melon{0 0.46 0.50 0 setcmykcolor}def /YellowOrange{0 0.42 1 0 setcmykcolor}def /Orange{0 0.61 0.87 0 setcmykcolor}def /BurntOrange{0 0.51 1 0 setcmykcolor}def /Bittersweet{0 0.75 1 0.24 setcmykcolor}def /RedOrange{0 0.77 0.87 0 setcmykcolor}def /Mahogany{0 0.85 0.87 0.35 setcmykcolor}def /Maroon{0 0.87 0.68 0.32 setcmykcolor}def /BrickRed{0 0.89 0.94 0.28 setcmykcolor}def /Red{0 1 1 0 setcmykcolor}def /OrangeRed{0 1 0.50 0 setcmykcolor}def /RubineRed{0 1 0.13 0 setcmykcolor}def /WildStrawberry{0 0.96 0.39 0 setcmykcolor}def /Salmon{0 0.53 0.38 0 setcmykcolor}def /CarnationPink{0 0.63 0 0 setcmykcolor}def /Magenta{0 1 0 0 setcmykcolor}def /VioletRed{0 0.81 0 0 setcmykcolor}def /Rhodamine{0 0.82 0 0 setcmykcolor}def /Mulberry{0.34 0.90 0 0.02 setcmykcolor}def /RedViolet{0.07 0.90 0 0.34 setcmykcolor}def /Fuchsia{0.47 0.91 0 0.08 setcmykcolor}def /Lavender{0 0.48 0 0 setcmykcolor}def /Thistle{0.12 0.59 0 0 setcmykcolor}def /Orchid{0.32 0.64 0 0 setcmykcolor}def /DarkOrchid{0.40 0.80 0.20 0 setcmykcolor}def /Purple{0.45 0.86 0 0 setcmykcolor}def /Plum{0.50 1 0 0 setcmykcolor}def /Violet{0.79 0.88 0 0 setcmykcolor}def /RoyalPurple{0.75 0.90 0 0 setcmykcolor}def /BlueViolet{0.86 0.91 0 0.04 setcmykcolor}def /Periwinkle{0.57 0.55 0 0 setcmykcolor}def /CadetBlue{0.62 0.57 0.23 0 setcmykcolor}def /CornflowerBlue{0.65 0.13 0 0 setcmykcolor}def /MidnightBlue{0.98 0.13 0 0.43 setcmykcolor}def /NavyBlue{0.94 0.54 0 0 setcmykcolor}def /RoyalBlue{1 0.50 0 0 setcmykcolor}def /Blue{1 1 0 0 setcmykcolor}def /Cerulean{0.94 0.11 0 0 setcmykcolor}def /Cyan{1 0 0 0 setcmykcolor}def /ProcessBlue{0.96 0 0 0 setcmykcolor}def /SkyBlue{0.62 0 0.12 0 setcmykcolor}def /Turquoise{0.85 0 0.20 0 setcmykcolor}def /TealBlue{0.86 0 0.34 0.02 setcmykcolor}def /Aquamarine{0.82 0 0.30 0 setcmykcolor}def /BlueGreen{0.85 0 0.33 0 setcmykcolor}def /Emerald{1 0 0.50 0 setcmykcolor}def /JungleGreen{0.99 0 0.52 0 setcmykcolor}def /SeaGreen{0.69 0 0.50 0 setcmykcolor}def /Green{1 0 1 0 setcmykcolor}def /ForestGreen{0.91 0 0.88 0.12 setcmykcolor}def /PineGreen{0.92 0 0.59 0.25 setcmykcolor}def /LimeGreen{0.50 0 1 0 setcmykcolor}def /YellowGreen{0.44 0 0.74 0 setcmykcolor}def /SpringGreen{0.26 0 0.76 0 setcmykcolor}def /OliveGreen{0.64 0 0.95 0.40 setcmykcolor}def /RawSienna{0 0.72 1 0.45 setcmykcolor}def /Sepia{0 0.83 1 0.70 setcmykcolor}def /Brown{0 0.81 1 0.60 setcmykcolor}def /Tan{0.14 0.42 0.56 0 setcmykcolor}def /Gray{0 0 0 0.50 setcmykcolor}def /Black{0 0 0 1 setcmykcolor}def /White{0 0 0 0 setcmykcolor}def %% fin de l extrait color.pro %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% autres couleurs %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /bleu {0 0 1 setrgbcolor} def /rouge {1 0 0 setrgbcolor} def /vert {0 .5 0 setrgbcolor} def /gris {.4 .4 .4 setrgbcolor} def /jaune {1 1 0 setrgbcolor} def /noir {0 0 0 setrgbcolor} def /blanc {1 1 1 setrgbcolor} def /orange {1 .65 0 setrgbcolor} def /rose {1 .01 .58 setrgbcolor} def /cyan {1 0 0 0 setcmykcolor} def /magenta {0 1 0 0 setcmykcolor} def %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% definition du point de vue %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% pour la 3D conventionnelle %% Dony : graphisme scientifique : page 187 %% Editeur : Masson %% calcul des coefficients de la matrice %% de transformation /Sin1 {THETA sin} def /Sin2 {PHI sin} def /Cos1 {THETA cos} def /Cos2 {PHI cos} def /Cos1Sin2 {Cos1 Sin2 mul} def /Sin1Sin2 {Sin1 Sin2 mul} def /Cos1Cos2 {Cos1 Cos2 mul} def /Sin1Cos2 {Sin1 Cos2 mul} def /3dto2d { 6 dict begin /Zcote exch def /Yordonnee exch def /Xabscisse exch def /xObservateur Xabscisse Sin1 mul neg Yordonnee Cos1 mul add def /yObservateur Xabscisse Cos1Sin2 mul neg Yordonnee Sin1Sin2 mul sub Zcote Cos2 mul add def /zObservateur Xabscisse neg Cos1Cos2 mul Yordonnee Sin1Cos2 mul sub Zcote Sin2 mul sub Dobs add def %% maintenant on depose les resultats sur la pile Decran xObservateur mul zObservateur div cm Decran yObservateur mul zObservateur div cm end } def /getpointVue { XpointVue YpointVue ZpointVue } def /GetCamPos { getpointVue } def %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% jps modifie pour PSTricks %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /solid {continu} def /dashed {pointilles} def %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% geometrie basique %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% syntaxe~: [x1 y1 ... xn yn] ligne /ligne { gsave newpath dup 0 getp smoveto ligne_ starfill stroke grestore } def %% syntaxe~: [x1 y1 ... xn yn] ligne_ /ligne_ { reversep aload length 2 idiv { slineto } repeat } def %% syntaxe~: [x1 y1 ... xn yn] polygone /polygone* { 1 dict begin /startest {true} def polygone end } def /polygone_ { newpath aload length 2 idiv 3 copy pop smoveto { slineto } repeat closepath } def /polygone { gsave polygone_ starfill currentlinewidth 0 eq {} {stroke} ifelse grestore } def %% syntaxe : x y point /point { gsave 1 setlinecap newpath smoveto 0 0 rlineto 5 setlinewidth stroke grestore } def /point_ { 1 setlinecap 5 setlinewidth smoveto 0 0 rlineto } def %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% %%%% %%%% insertion librairie jps %%%% %%%% %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% le repere jps %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### AAAopacity ### %% les parametres pour la gestion de la transparence /setstrokeopacity { /strokeopacity exch def } def /setfillopacity { /fillopacity exch def } def %% d apres un code de Jean-Michel Sarlat %% http://melusine.eu.org/syracuse/swf/pdf2swf/setdash/ %% Mise en reserve de la procedure stroke originelle. /sysstroke {systemdict /stroke get exec} def /sysfill {systemdict /fill get exec} def /sysatan {systemdict /atan get exec} def /atan {2 copy 0 0 eqp {pop pop 0} {sysatan} ifelse} def % Mise en place de la nouvelle procedure /stroke { /strokeopacity where { /strokeopacity get } { 1 } ifelse .setopacityalpha sysstroke } def /fill { /fillopacity where { /fillopacity get } { 1 } ifelse .setopacityalpha sysfill } def %%%%% ### AAAscale ### %%%%%%%%%%%%%%%% les deplacements a l echelle %%%%%%%%%%%%%%%%%%% /v@ct_I {xunit 0} def /v@ct_J {angle_repere cos yunit mul angle_repere sin yunit mul} def /xscale {} def /yscale {} def /xscale-1 {} def /yscale-1 {} def /gtransform {} def /gtransform-1 {} def /jtoppoint { 2 dict begin gtransform /y exch yscale def /x exch xscale def v@ct_I x mulv v@ct_J y mulv addv end } def /rptojpoint { xtranslate ytranslate 3 1 roll %% xA yB yA xB 4 1 roll %% xB xA yB yA sub neg 3 1 roll %% yB-yA xB xA sub neg exch ptojpoint } def /rptoppoint { xtranslate ytranslate 3 1 roll %% xA yB yA xB 4 1 roll %% xB xA yB yA sub neg 3 1 roll %% yB-yA xB xA sub neg exch } def /ptojpoint { 4 dict begin /Y exch yscale-1 def /X exch xscale-1 def /y Y yunit angle_repere sin mul div def /x X y yunit mul angle_repere cos mul sub xunit div def x y gtransform-1 end } def /smoveto { jtoppoint moveto } def /srmoveto { jtoppoint rmoveto } def /slineto { jtoppoint lineto } def /srlineto { jtoppoint rlineto } def /stranslate { jtoppoint translate } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% methodes numeriques %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### solve2nddegre ### %% syntaxe : a b c solve2nddegre --> x1 x2 /solve2nddegre { 5 dict begin /@c exch def /@b exch def /@a exch def /delt@ @b dup mul 4 @a mul @c mul sub def @b neg delt@ sqrt sub 2 @a mul div @b neg delt@ sqrt add 2 @a mul div end } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% la 2D %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% points %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### tripointangle ### %% syntaxe : A B C tripointangle --> angle ABC /tripointangle { 9 dict begin /yC exch def /xC exch def /yB exch def /xB exch def /yA exch def /xA exch def /A {xA yA} def /B {xB yB} def /C {xC yC} def B C angle B A angle sub end } def %%%%% ### angle ### %% syntaxe : A B angle %% --> num, l'angle defini par le vecteur AB dans le repere orthonorme jps /angle { vecteur exch atan dup 180 gt {360 sub} if } def %% syntaxe : A B pangle %% --> num, l'angle defini par le vecteur AB dans le repere postscript /pangle { jtoppoint exchp jtoppoint exchp vecteur exch atan dup 180 gt {360 sub} if } def %%%%% ### setxrange ### /setxrange { /xmax exch def /xmin exch def } def %%%%% ### setyrange ### /setyrange { /ymax exch def /ymin exch def } def %%%%% ### defpoint ### %% syntaxe : xA yA /A defpoint /defpoint { 1 dict begin /t@mp@r@ire exch def [ 3 1 roll ] cvx t@mp@r@ire exch end def } def %%%%% ### milieu ### %% syntaxe~: A B milieu /milieu { %% xA yA xB yB 3 -1 roll %% xA xB yB yA add 2 div %% xA xB yM 3 1 roll %% yM xA xB add 2 div %% yM xM exch } def %%%%% ### parallelopoint ### %% syntaxe : A B C parallelopoint --> point D, tel que ABCD parallelogramme /parallelopoint { 11 dict begin /yC exch def /xC exch def /yB exch def /xB exch def /yA exch def /xA exch def /A {xA yA} def /B {xB yB} def /C {xC yC} def /d1 {A B C paral} def /d2 {B C A paral} def d1 d2 interdroite end } def %%%%% ### translatepoint ### %% syntaxe : A u translatepoint --> B image de A par la translation de vecteur u /translatepoint { addv } def %%%%% ### rotatepoint ### %% syntaxe : B A r rotatepoint --> C image de B par la rotation de centre A, %% d'angle r (en degre) %% En prenant les affixes des pts associes, il vient %% (zC - zA) = (zB-zA) e^(ir) %% soit %% zC = (zB-zA) e^(ir) + zA /rotatepoint { %% B, A, r 5 copy %% B, A, r, B, A, r cos 5 1 roll %% B, A, r, cos r, B, A 4 1 roll %% B, A, r, cos r, yA, B, xA 4 1 roll %% B, A, r, cos r, A, B vecteur %% B, A, r, cos r, xB-xA, yB-yA 4 -1 roll sin %% B, A, cos r, xB-xA, yB-yA, sin r 4 copy mul %% B, A, cos r, xB-xA, yB-yA, sin r, cos r, xB-xA, (yB-yA) sin r 7 1 roll mul %% B, A, (yB-yA) sin r, cos r, xB-xA, yB-yA, sin r, cos r (xB-xA) 5 1 roll %% B, A, (yB-yA) sin r, cos r (xB-xA), cos r, xB-xA, yB-yA, sin r exch %% B, A, (yB-yA) sin r, cos r (xB-xA), cos r, xB-xA, sin r, yB-yA 4 -1 roll mul %% B, A, (yB-yA) sin r, cos r (xB-xA), xB-xA, sin r, (yB-yA)cos r 3 1 roll mul %% B, A, (yB-yA) sin r, cos r (xB-xA), (yB-yA) cos r, (xB-xA) sin r add %% B, A, (yB-yA) sin r, cos r (xB-xA), (yB-yA) cos r +(xB-xA) sin r 3 1 roll %% B, A, (yB-yA) cos r + (xB-xA) sin r, (yB-yA) sin r, cos r (xB-xA), exch sub %% B, A, (yB-yA) cos r + (xB-xA) sin r, cos r (xB-xA)-(yB-yA) sin r exch %% B, zA, (zB-zA) e^(ir) addv 3 -1 roll pop 3 -1 roll pop } def %%%%% ### hompoint ### %% syntaxe : B A alpha hompoint -> le point A' tel que AA' = alpha AB /hompoint { 5 copy pop vecteur %% vecteur BA 3 -1 roll neg mulv %% alpha x vecteur AB addv 4 -1 roll 4 -1 roll pop pop } def %%%%% ### orthoproj ### %% syntaxe : A D orthoproj --> B, le projete orthogonal de A sur D /orthoproj { 6 -1 roll 6 -1 roll %% D A 6 copy %% D A D A 7 -1 roll pop 7 -1 roll pop %% D D A perp interdroite } def %% syntaxe : A projx --> le projete orthogonal de A sur Ox /projx { pop 0 } def %% syntaxe : A projy --> le projete orthogonal de A sur Oy /projy { exch pop 0 exch } def %%%%% ### sympoint ### %% syntaxe : A I sympoint --> point A', le symetrique de A par rapport %% au point I /sympoint { 4 copy pop pop vecteur -2 mulv addv } def %%%%% ### axesympoint ### %% syntaxe : A D axesympoint --> point B, le symetrique de A par rapport %% a la droite D /axesympoint { 2 dict begin 6 copy pop pop pop pop /yA exch def /xA exch def orthoproj xA yA vecteur -2 mulv xA yA addv end } def %%%%% ### cpoint ### %% syntaxe : alpha C cpoint -> M, le point du cercle C correspondant a %% l'angle alpha /cpoint { %% a, xI, yI, r 1 dict begin dup %% a, xI, yI, r, r 5 -1 roll %% xI, yI, r, r, a /alpha exch def alpha cos mul %% xI, yI, r, r cos a exch alpha sin mul %% xI, yI, r cos a, r sin a 3 -1 roll add %% xI, r cos a, yI + r sin a 3 1 roll %% yI + r sin a, xI, r cos a, add exch %% xI + r cos a, yI + r sin a end } def %%%%% ### xdpoint ### %% x A B xdpoint : le point de la droite (AB) d'abscisse x /xdpoint { 5 dict begin /pt2 defpoint /pt1 defpoint /x exch def /a pt1 pt2 coeffdir def /b pt1 pt2 ordorig def x dup a mul b add end } def %%%%% ### ydpoint ### %% y A B ydpoint : le point de la droite (AB) d'ordonnee y /ydpoint { 5 dict begin /pt2 defpoint /pt1 defpoint /y exch def pt1 pt2 verticale? { pt1 pop y } { /a pt1 pt2 coeffdir def /b pt1 pt2 ordorig def y b sub a div y } ifelse end } def %%%%% ### ordonnepoints ### %% syntaxe : xA yA xB yB ordonnepoints --> idem si yB>yA ou si yB=yA %% avec xB>xA, sinon xB yB xA yA /ordonnepoints { 4 copy exch pop %% ... xA, yA, yB lt %% yA < yB ? {pop} %% oui, c'est fini { %% non : yA >= yB pop 4 copy exch pop %% ... xA, yA, yB eq %% yA = yB ? { 3 copy %% oui, yA = yB pop pop %% ... xA, xB le %% xA =< xB ? {} %% oui, c'est fini { %% non, on echange A et B 4 -1 roll 4 -1 roll } ifelse } { %% non : yA < yB => on echange A et B pop 4 -1 roll 4 -1 roll } ifelse } ifelse } def %%%%% ### distance ### %% syntaxe~: A B distance /distance { %% xA yA xB yB vecteur %% x y dup mul exch %% y^2 x dup mul %% y^2 x^2 add sqrt } def %%%%% ### dup ### /dupp {2 copy} def /dupc {3 copy} def /dupd {4 copy} def %%%%% ### fin insertion ### /interdroites {interdroite} def %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% vecteurs %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### vecteur ### %% syntaxe~: A B vecteur /vecteur { %% xA yA xB yB 3 -1 roll %% xA xB yB yA sub %% xA xB yB-yA 3 1 roll %% yB-yA xA xB exch sub %% yB-yA xB-xA exch } def %%%%% ### normalize ### %% syntaxe : u normalize -> u / ||u|| /normalize { 2 dict begin /u defpoint /n u norme def u 1 n div mulv end } def %%%%% ### addv ### %% syntaxe : u v addv --> u+v /addv { %% xA yA xB yB 3 1 roll %% xA yB yA xB 4 1 roll %% xB xA yB yA add 3 1 roll %% yB+yA xB xA add exch } def %%%%% ### subv ### %% syntaxe : u v subv --> u - v /subv { %% xA yA xB yB -1 mulv addv } def %%%%% ### mulv ### %% syntaxe : u a mulv --> au /mulv { %% xA, yA, a dup %% xA, yA, a, a 3 1 roll %% xA, a, yA, a mul 3 1 roll %% ayA, xA, a mul exch } def %%%%% ### scalprod ### %% syntaxe : u v scalprod --> le produit scalaire de u par v /scalprod { 2 dict begin /y' exch def exch /y exch def mul y y' mul add end } def %%%%% ### normal ### %% syntaxe : u normal --> v tel u.v = 0 /normal { neg exch } def %%%%% ### norme ### %% syntaxe : u norme --> |u| /norme { dup mul exch dup mul add sqrt } def %%%%% ### oldarrow ### %% syntaxe : A B oldarrow --> trace fleche en B, direction AB /oldarrow { 4 dict begin gsave /B defpoint /A defpoint oldarrowscale scale oldarrowangle rotate newpath B smoveto A B vecteur normalize /u defpoint u neg exch /v defpoint u oldarrowpointe neg mulv rmoveto %% ainsi c'est la pointe qui est en (0, 0) %% le pt extremal arriere haut u oldarrowplume neg mulv %% l'abscisse v oldarrow@ngle sin oldarrow@ngle cos div oldarrowplume mul mulv addv %% l'ordonnee rlineto u oldarrowplume oldarrowpointe add mulv v oldarrow@ngle sin oldarrow@ngle cos div oldarrowplume mul neg mulv addv rlineto u oldarrowplume oldarrowpointe add neg mulv v oldarrow@ngle sin oldarrow@ngle cos div oldarrowplume mul neg mulv addv rlineto closepath fill grestore end } def /oldarrowpointe {xunit 5 div} def /oldarrowplume {xunit 10 div} def /oldarrow@ngle 45 def /oldarrowscale {1 1} def /oldarrowangle 0 def %% pour l'utilisateur %%%%% ### drawvecteur ### %% syntaxe : A B drawvecteur /drawvecteur { 2 dict begin /B defpoint /A defpoint [A B] ligne A B oldarrow end } def %%%%% ### orthovecteur ### %% syntaxe : u orthovecteur --> v, vecteur orthogonal a u /orthovecteur { neg exch } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% cercles %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### defcercle ### %% syntaxe : A r /d defcercle /defcercle { 1 dict begin /t@mp@r@ire exch def [ 4 1 roll ] cvx t@mp@r@ire exch end def } def %%%%% ### interdroitecercle ### %% intersection de la droite y = ax+b avec le cercle (x-x0)^2 + (y-y0)^2 = r^2 %% { -- b - y 2 2 3 %% { | x = - -----, y = (b + a x0 + a y0 + (2 a b y0 - 2 a b x0 + %% { -- a %% %% 3 2 2 2 2 4 2 2 2 4 2 2 %% 2 a x0 y0 - a b + a r + a r - a y0 - a x0 )^(1/2)) / (a + 1) %% %% %% -- %% |, %% -- %% -- b - y 2 2 3 %% | x = - -----, y = (b + a x0 + a y0 - (2 a b y0 - 2 a b x0 + %% -- a %% %% 3 2 2 2 2 4 2 2 2 4 2 2 %% 2 a x0 y0 - a b + a r + a r - a y0 - a x0 )^(1/2)) / (a + 1) %% %% -- } %% | } %% -- } %% intersection de la droite x = a avec le cercle (x-x0)^2 + (y-y0)^2 = r^2 %% 2 2 2 1/2 %% {[x = a, y = y0 + (2 a x0 - a + r - x0 ) ], %% %% 2 2 2 1/2 %% [x = a, y = y0 - (2 a x0 - a + r - x0 ) ]} %% intersection de la droite y = b avec le cercle (x-x0)^2 + (y-y0)^2 = r^2 %% 2 2 2 1/2 %% {[y = b, x = x0 + (2 b y0 - b + r - y0 ) ], %% %% 2 2 2 1/2 %% [y = b, x = x0 - (2 b y0 - b + r - y0 ) ]} %% syntaxe : D I r interdroitecercle /interdroitecercle { 16 dict begin /r exch def /y0 exch def /x0 exch def /yB exch def /xB exch def /yA exch def /xA exch def xA yA xB yB verticale? %% la droite est verticale { /xpt1 xA def /xpt2 xA def /quantite 2 xA mul x0 mul xA dup mul sub r dup mul add x0 dup mul sub sqrt def /ypt1 y0 quantite add def /ypt2 y0 quantite sub def } %% la droite n'est pas verticale { /a xA yA xB yB coeffdir def /b xA yA xB yB ordorig def 0 a eq %% la droite est horizontale { /quantite 2 b mul y0 mul b dup mul sub r dup mul add y0 dup mul sub sqrt def /xpt1 x0 quantite add def /xpt2 x0 quantite sub def /ypt1 b def /ypt2 b def } %% la droite n'est pas horizontale { /quantite1 b a x0 mul add a dup mul y0 mul add def /quantite2 2 a dup mul mul b mul y0 mul 2 a 3 exp mul b mul x0 mul sub 2 a 3 exp mul x0 mul y0 mul add a dup mul b dup mul mul sub a dup mul r dup mul mul add a 4 exp r dup mul mul add a dup mul y0 dup mul mul sub a 4 exp x0 dup mul mul sub sqrt def /quantite3 a dup mul 1 add def /ypt1 quantite1 quantite2 add quantite3 div def /xpt1 ypt1 b sub a div def /ypt2 quantite1 quantite2 sub quantite3 div def /xpt2 ypt2 b sub a div def } ifelse } ifelse xpt1 ypt1 xpt2 ypt2 ordonnepoints end } def %%%%% ### intercercle ### %% syntaxe : cerc1 cerc2 intercercle --> A B les points d'intersection %% des 2 cercles, tries par 'ordonnepoints' /intercercle { 12 dict begin /r2 exch def /y2 exch def /x2 exch def /r1 exch def /y1 exch def /x1 exch def %% on translate pour se ramener a (x1, y1) = (0, 0) x2 y2 x1 y1 subv /y2 exch def /x2 exch def %% on prepare l'equation du 2nd degre %% 2 2 2 %% {y = RootOf((4 x2 + 4 y2 ) _Z %% %% 3 2 2 2 4 %% + (-4 y2 - 4 r1~ y2 + 4 y2 r2~ - 4 x2 y2) _Z + x2 %% %% 4 2 2 2 2 2 2 2 2 %% + r2~ - 2 y2 r2~ + 2 x2 y2 - 2 x2 r2~ - 2 r1~ x2 %% %% 4 4 2 2 2 2 %% + r1~ + y2 + 2 r1~ y2 - 2 r1~ r2~ ), x = 1/2 (-2 y2 %% %% 2 2 2 %% RootOf((4 x2 + 4 y2 ) _Z %% %% 3 2 2 2 4 %% + (-4 y2 - 4 r1~ y2 + 4 y2 r2~ - 4 x2 y2) _Z + x2 %% %% 4 2 2 2 2 2 2 2 2 %% + r2~ - 2 y2 r2~ + 2 x2 y2 - 2 x2 r2~ - 2 r1~ x2 %% %% 4 4 2 2 2 2 2 2 2 %% + r1~ + y2 + 2 r1~ y2 - 2 r1~ r2~ ) + r1~ + x2 + y2 %% %% 2 %% - r2~ )/x2} %% coeff pour le degre 2 /a %% 2 2 2 %% {y = RootOf((4 x2 + 4 y2 ) _Z 4 x2 dup mul mul 4 y2 dup mul mul add def %% coeff pour le degre 1 %% /b %% 3 2 2 2 %% + (-4 y2 - 4 r1~ y2 + 4 y2 r2~ - 4 x2 y2) _Z -4 y2 3 exp mul 4 r1 dup mul mul y2 mul sub 4 r2 dup mul mul y2 mul add 4 x2 dup mul mul y2 mul sub def %% coeff pour le degre 0 %% /c { %% 4 %% + x2 x2 4 exp %% %% 4 2 2 2 2 2 2 2 2 %% + r2~ - 2 y2 r2~ + 2 x2 y2 - 2 x2 r2~ - 2 r1~ x2 r2 4 exp add 2 y2 dup mul mul r2 dup mul mul sub 2 x2 dup mul mul y2 dup mul mul add 2 x2 dup mul mul r2 dup mul mul sub 2 x2 dup mul mul r1 dup mul mul sub %% %% 4 4 2 2 2 2 %% + r1~ + y2 + 2 r1~ y2 - 2 r1~ r2~ ) r1 4 exp add y2 4 exp add 2 r1 dup mul mul y2 dup mul mul add 2 r1 dup mul mul r2 dup mul mul sub } def a b c solve2nddegre /Y1 exch def /Y0 exch def /X0 %% x = 1/2 (-2 y2 Y -2 y2 mul Y0 mul %% %% 2 2 2 %% + r1~ + x2 + y2 r1 dup mul add x2 dup mul add y2 dup mul add %% %% 2 %% - r2~ )/x2} r2 dup mul sub 2 x2 mul div def /X1 %% x = 1/2 (-2 y2 Y -2 y2 mul Y1 mul %% %% 2 2 2 %% + r1~ + x2 + y2 r1 dup mul add x2 dup mul add y2 dup mul add %% %% 2 %% - r2~ )/x2} r2 dup mul sub 2 x2 mul div def %% on depose le resultat, en n'oubliant pas de retranslater en sens %% inverse X0 Y0 x1 y1 addv X1 Y1 x1 y1 addv ordonnepoints end } def %%%%% ### ABcercle ### %% syntaxe : A B C ABcercle --> le cercle passant par A, B, C /ABcercle { 3 dict begin /@3 defpoint /@2 defpoint /@1 defpoint @1 @2 mediatrice @1 @3 mediatrice interdroite dupp @3 distance end } def %%%%% ### diamcercle ### %% syntaxe : A B diamcercle --> le cercle de diametre [AB] /diamcercle { 4 copy distance 2 div 5 1 roll milieu 3 -1 roll } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% droites %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### horizontale ### %% syntaxe : y horizontale /horizontale { 1 dict begin /y exch def xmin y xmax y end } def %%%%% ### coeffdir ### %% syntaxe~: A B coeffdir /coeffdir { vecteur exch div } def %%%%% ### ordorig ### %% syntaxe : A B ordorig %% attention, la droite est supposee ne pas etre verticale /ordorig { /dr@ite 4 array def dr@ite 3 3 -1 roll put dr@ite 2 3 -1 roll put dr@ite 1 3 -1 roll put dr@ite 0 3 -1 roll put dr@ite aload pop coeffdir /c@eff exch def dr@ite aload pop pop pop %% xA yA exch %% yA xA c@eff mul neg add } def %%%%% ### verticale ### %% syntaxe~: A B verticale? /verticale? { pop 2 1 roll pop eq } def %% syntaxe : x verticale /verticale { 1 dict begin /x exch def x ymin x ymax end } def %%%%% ### droite ### %% %% syntaxe : A B droite %% /droite { %% gsave %% 6 dict begin %% /yB exch def %% /xB exch def %% /yA exch def %% /xA exch def %% xA yA xB yB %% eqp %% {} %% { %% xA yA xB yB %% verticale? %% { %% newpath %% xA ymin smoveto %% xA ymax slineto %% stockcurrentcpath %% stroke %% } %% { %% newpath %% /alpha xA yA xB yB coeffdir def %% /beta xA yA xB yB ordorig def %% xmin dup alpha mul beta add smoveto %% xmax dup alpha mul beta add slineto %% stockcurrentcpath %% stroke %% } %% ifelse %% } %% ifelse %% end %% grestore %% } def %% syntaxe : A B droite /droite { gsave 6 dict begin /B defpoint /A defpoint A pop B pop eq { %% droite verticale newpath A pop ymin smoveto A pop ymax slineto stockcurrentcpath stroke } { %% on cherche le point le + a gauche xmin A B xdpoint /C defpoint C exch pop ymin lt { %% trop a gauche ymin A B ydpoint /C defpoint } if C exch pop ymax gt { %% trop a gauche ymax A B ydpoint /C defpoint } if %% on cherche le point le + a droite xmax A B xdpoint /D defpoint D exch pop ymin lt { %% trop a droite ymin A B ydpoint /D defpoint } if D exch pop ymax gt { %% trop a gauche ymax A B ydpoint /D defpoint } if newpath C smoveto D slineto stockcurrentcpath stroke } ifelse end grestore } def %%%%% ### defdroite ### %% syntaxe : A B /d defdroite /defdroite { 1 dict begin /t@mp@r@ire exch def [ 5 1 roll ] cvx t@mp@r@ire exch end def } def %%%%% ### paral ### %% syntaxe : D A paral --> droite parallele a D passant par A /paral { 4 dict begin /yA exch def /xA exch def vecteur /u2 exch def /u1 exch def xA yA 2 copy u1 u2 translatepoint end } def %%%%% ### interdroite ### /interdroite { %% A B C D /dr@ite2 4 array def dr@ite2 3 3 -1 roll put dr@ite2 2 3 -1 roll put dr@ite2 1 3 -1 roll put dr@ite2 0 3 -1 roll put /dr@ite1 4 array def dr@ite1 3 3 -1 roll put dr@ite1 2 3 -1 roll put dr@ite1 1 3 -1 roll put dr@ite1 0 3 -1 roll put %%% %% trace pour deboguage %%% dr@ite1 aload pop droite %%% dr@ite2 aload pop droite %%% Dans tous les cas, on suppose que l'intersection existe %%% %%% * la 1ere droite est verticale. les equations reduites sont %%% x = a1 et y = a2 x + b2 %%% Le point d'intersection est : %%% {{x = a1, y = b2 + a1 a2}} %%% %%% * la 2eme droite est verticale. les equations reduites sont %%% x = a1 x+ b1 et x = a2 %%% Le point d'intersection est : %%% {{x = a2, y = b1 + a1 a2}} %%% %%% * aucune n'est verticale. Les equations reduites sont %%% y = a1 x + b1 et y = a2 x + b2 %%% Le point d'intersection est : %%% { { b2 - b1 a1 b2 - a2 b1 } } %%% { { x = -------, y = ------------- } } %%% { { a1 - a2 a1 - a2 } } %%% remarque : pour le moment, je n'arrive pas a rendre mes variables %%% locales : elle restent globales. Pour que cela ne soit pas trop %%% genant, je les note respectivement @1, @@1, @2 et @@2 au lieu de a1, %%% b1, a2 et b2. dr@ite1 aload pop verticale? { /@1 {dr@ite1 aload pop pop pop pop} def /@2 {dr@ite2 aload pop coeffdir} def /@@2 {dr@ite2 aload pop ordorig} def @1 @1 @2 mul @@2 add } { dr@ite2 aload pop verticale? { /@1 {dr@ite1 aload pop coeffdir} def /@@1 {dr@ite1 aload pop ordorig} def /@2 {dr@ite2 aload pop pop pop pop} def @2 @1 @2 mul @@1 add } { /@1 {dr@ite1 aload pop coeffdir} def /@@1 {dr@ite1 aload pop ordorig} def /@2 {dr@ite2 aload pop coeffdir} def /@@2 {dr@ite2 aload pop ordorig} def @@2 @@1 sub @1 @2 sub div @1 @@2 mul @2 @@1 mul sub @1 @2 sub div } ifelse } ifelse } def %%%%% ### perp ### %% syntaxe : D A perp --> droite perpendiculaire a D passant par A /perp { 4 dict begin /yA exch def /xA exch def vecteur orthovecteur /u2 exch def /u1 exch def xA yA 2 copy u1 u2 translatepoint end } def %%%%% ### mediatrice ### %% synaxe : A B mediatrice --> droite /mediatrice { 4 copy milieu perp } def %%%%% ### bissectrice ### %% syntaxe : A B C bissectrice --> B E ou E est un point de la bissectrice /bissectrice { 10 dict begin /yC exch def /xC exch def /yB exch def /xB exch def /yA exch def /xA exch def /A {xA yA} def /B {xB yB} def /C {xC yC} def /alpha {A B C tripointangle} def B A B alpha rotatepoint A milieu end } def %%%%% ### angledroit ### /widthangledroit 5 def %% syntaxe : A B C angledroit --> dessine un angle droit en B /angledroit { 10 dict begin dup xcheck { /widthangledroit exch def } if /C defpoint /B defpoint /A defpoint B C vecteur normalize widthangledroit 20 div mulv /u defpoint B A vecteur normalize widthangledroit 20 div mulv /v defpoint [B u addv dupp v addv B v addv] ligne end } def %%%%% ### translatedroite ### %% syntaxe : A B u translatedroite --> C D images resp de A et B par la translation de vecteur u /translatedroite { %% A B u 2 copy %% A B u u 6 1 roll 6 1 roll %% A u B u addv %% A u D 6 1 roll 6 1 roll %% D A u addv 4 1 roll 4 1 roll } def %%%%% ### rotatedroite ### %% syntaxe : A B O r rotatedroite --> C D images resp de A et B par la %% rotation de centre O et d'angle r (en degre) /rotatedroite { 5 copy rotatepoint %% A B O r D 6 -1 roll pop %% A xB O r D 6 -1 roll pop %% A O r D 7 1 roll 7 1 roll rotatepoint %% D C 4 1 roll 4 1 roll } def /rotatevecteur { rotatedroite } def /rotatesegment { rotatedroite } def %%%%% ### axesymdroite ### %% syntaxe : d D axesymdroite --> droite d', symetrique de la droite d par rapport %% a la droite D /axesymdroite { 2 dict begin /D defdroite /B defpoint D axesympoint B D axesympoint end } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% polygones %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### poltransformfile ### %% syntaxe : pol u translatepol --> pol' /translatepol { 2 dict begin /uy exch def /ux exch def {ux uy translatepoint} papply end } def %% syntaxe : pol u rotatepol --> pol' /rotatepol { 2 dict begin /alpha exch def /I defpoint {I alpha rotatepoint} papply end } def %% syntaxe : pol I alpha hompol --> pol' /hompol { 2 dict begin /alpha exch def /I defpoint {I alpha hompoint} papply end } def %% syntaxe : pol I sympol --> pol' /sympol { 1 dict begin /I defpoint {I sympoint} papply end } def %% syntaxe : pol D axesympol --> pol' /axesympol { 1 dict begin /D defdroite {D axesympoint} papply end } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% les tests %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### isbool ### %% syntaxe : any isbool --> booleen /isbool { type (booleantype) cvn eq } def %%%%% ### isarray ### %% syntaxe : any isarray --> booleen /isarray { type (arraytype) cvn eq } def %%%%% ### isstring ### %% syntaxe : any isstring --> booleen /isstring { type (stringtype) cvn eq } def %%%%% ### isinteger ### %% syntaxe : any isinteger --> booleen /isinteger { type (integertype) cvn eq } def %%%%% ### isnum ### %% syntaxe : any isnum --> booleen /isnum { dup isreal exch isinteger or } def %%%%% ### isreal ### %% syntaxe : any isreal --> booleen /isreal { type (realtype) cvn eq } def %%%%% ### eq ### %% syntaxe : A B eqp3d --> booleen = true si les points A et B sont identiques /eqp3d { %% x1 y1 z1 x2 y2 z2 4 -1 roll %% x1 y1 x2 y2 z2 z1 eq { %% x1 y1 x2 y2 eqp } { pop pop pop pop false } ifelse } def %% syntaxe : A B eqp --> booleen = true si les points A et B sont identiques /eqp { 3 -1 roll eq { eq {true} {false} ifelse } {pop pop false} ifelse } def %% syntaxe : z z' eqc --> true si z = z', false sinon /eqc { eqp } def %%%%% ### eqstring ### /eqstring { 3 dict begin /str2 exch def /str1 exch def str1 length str2 length eq { /i 0 def true str1 length { str1 i get str2 i get eq and /i i 1 add store } repeat } { false } ifelse end } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% conversions de types %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### astr2str ### %% syntaxe : array str astr2str --> str %% convertit le contenu de array en chaines de caracteres puis les %% concatene avec str, en inserant un caractere "space" apres chaque %% element du tableau array /astr2str { 5 dict begin /str exch def /table exch def /n table length def n 0 eq { str } { table 0 n 1 sub getinterval table n 1 sub get ( ) cvs ( ) append str append astr2str } ifelse end } def %%%%% ### numstr2array ### %% syntaxe : str str2num --> num /str2num { 5 dict begin /str exch def /n str length def /signnum 1 def /frct false def /k 0 def 0 1 n 1 sub { /i exch def str i get dup 46 eq { %% il y a un point /frct true def pop i 0 eq { 0 } if } { dup 45 eq { /signnum -1 def pop } { frct not { i 1 ge signnum 0 ge and i 2 ge or { exch 10 mul 48 sub add } { 48 sub } ifelse } { 48 sub /k k 1 add store 10 k exp div add } ifelse } ifelse } ifelse } for signnum mul end } def /str2num {cvx exec} def %% syntaxe : str numstr2array -> array %% ou str est une chaine de nombres reels separes par des espaces %% et array est constitue des elements numeriques de string. %% exemple : %% (0 -12 .234 54) --> [0 -12 0.234 54] /numstr2array { 6 dict begin /str exch def /n str length def /separateurs [] def [ 0 1 n 1 sub { /i exch def str i get 32 eq { /separateurs [separateurs aload pop i] def } if } for /j 0 def /oldsep 0 def 0 1 separateurs length 1 sub { /i exch def str j separateurs i get oldsep sub getinterval str2num /j separateurs i get 1 add def /oldsep separateurs i get 1 add def } for str j n oldsep sub getinterval str2num ] end } def %% syntaxe : array numstr2array -> array /arraynumstr2arrayarray { {numstr2array} apply } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% macros de projection %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### projtext ### %% syntaxe : str x0 y0 z0 [normal_vect] ultextp3d --> - %% syntaxe : str x0 y0 z0 [normal_vect] bool ultextp3d --> - %% syntaxe : str x0 y0 plantype ultextp3d --> - %% syntaxe : str x0 y0 plantype bool ultextp3d --> - %% syntaxe : str1 solid i str2 ultextp3d --> - %% syntaxe : str1 solid i str2 bool ultextp3d --> - %% syntaxe : str1 solid i alpha str2 bool ultextp3d --> - /initpr@jtext { 5 dict begin dup isbool { /mybool exch def } { /mybool true def } ifelse dup isplan { /type_plan_proj true def /lepl@n exch def lepl@n plangetbase aload pop /@V defpoint3d /@U defpoint3d lepl@n plangetorigine /z0 exch def /y0 exch def /x0 exch def /table [@U @U @V vectprod3d] def } { dup isarray { %% c est un planprojpath /type_plan_proj true def /table exch def /z0 exch def /y0 exch def /x0 exch def 0 0 } { %% c est un solidprojpath /type_plan_proj false def %% y a-t-il un str2 dup isstring { /str2 exch def } { /str2 {} def } ifelse %% y a-t-il un alpha 2 copy pop issolid { /alpha 0 def } { /alpha exch def } ifelse /i exch def /solid exch def 0 0 } ifelse } ifelse } def /closepr@jtext { type_plan_proj { x0 y0 z0 table mybool projpath } { solid i alpha str2 mybool projpath } ifelse fill stroke end } def %% syntaxe : str x0 y0 z0 [normal_vect] ultextp3d --> - %% syntaxe : str x0 y0 z0 [normal_vect] bool ultextp3d --> - %% syntaxe : str1 solid i str2 ultextp3d --> - %% syntaxe : str1 solid i str2 bool ultextp3d --> - %% syntaxe : str1 solid i alpha str2 bool ultextp3d --> - /ultextp3d {initpr@jtext ultext_ closepr@jtext} def /cltextp3d {initpr@jtext cltext_ closepr@jtext} def /bltextp3d {initpr@jtext bltext_ closepr@jtext} def /dltextp3d {initpr@jtext dltext_ closepr@jtext} def /ubtextp3d {initpr@jtext ubtext_ closepr@jtext} def /cbtextp3d {initpr@jtext cbtext_ closepr@jtext} def /bbtextp3d {initpr@jtext bbtext_ closepr@jtext} def /dbtextp3d {initpr@jtext dbtext_ closepr@jtext} def /uctextp3d {initpr@jtext uctext_ closepr@jtext} def /cctextp3d {initpr@jtext cctext_ closepr@jtext} def /bctextp3d {initpr@jtext bctext_ closepr@jtext} def /dctextp3d {initpr@jtext dctext_ closepr@jtext} def /urtextp3d {initpr@jtext urtext_ closepr@jtext} def /crtextp3d {initpr@jtext crtext_ closepr@jtext} def /brtextp3d {initpr@jtext brtext_ closepr@jtext} def /drtextp3d {initpr@jtext drtext_ closepr@jtext} def %%%%% ### currentppathtransform ### %% syntaxe : {f} currentppathtransform --> applique la transformation f %% au chemin courant /currentppathtransform { 6 dict begin /warp exch def %% pour remplacer 'move' /warpmove{ 2 index { newpath } if warp moveto pop false } def %% pour remplacer 'lineto' /warpline { warp lineto } bind def %% pour remplacer 'curveto' /warpcurve { 6 2 roll warp 6 2 roll warp 6 2 roll warp curveto } bind def true { warpmove } { warpline } { warpcurve } { closepath } pathforall pop end } def %% syntaxe : {f} currentpathtransform --> applique la transformation f %% au chemin courant /currentpathtransform { 7 dict begin /transform exch def /warp {ptojpoint transform} def %% pour remplacer 'move' /warpmove{ 2 index { newpath } if warp smoveto pop false } def %% pour remplacer 'lineto' /warpline { warp slineto } bind def %% pour remplacer 'curveto' /warpcurve { 6 2 roll warp 6 2 roll warp 6 2 roll warp scurveto } bind def true { warpmove } { warpline } { warpcurve } { closepath } pathforall pop end } def %%%%% ### normalvect_to_orthobase ### %% syntaxe : [normal_vect] normalvect_to_orthobase %% --> imI imJ imK /normalvect_to_orthobase { 4 dict begin dup length 3 eq { aload pop normalize3d /normal_vect defpoint3d normal_vect -1 0 0 eqp3d { /imageI {0 -1 0} def /imageK {-1 0 0} def /imageJ {0 0 1} def } { %% on calcule l image de la base (I,J,K) /imageJ {normal_vect 1 0 0 vectprod3d normalize3d} def /imageK {normal_vect} def /imageI {imageJ imageK vectprod3d} def 1 0 0 imageK angle3d 0 eq { 0 1 0 normal_vect vectprod3d /imageI defpoint3d /imageJ {0 1 0} def normal_vect /imageK defpoint3d } if } ifelse } { dup length 6 eq { aload pop normalize3d /imageK defpoint3d normalize3d /imageI defpoint3d imageK imageI vectprod3d /imageJ defpoint3d } { dup length 7 eq { aload pop /alpha exch 2 div def normalize3d /imageK defpoint3d normalize3d /imageI defpoint3d imageK imageI vectprod3d /imageJ defpoint3d %% et ensuite, on fait tourner la base autour de imageK imageI alpha cos mulv3d imageJ alpha sin mulv3d addv3d imageI alpha sin neg mulv3d imageJ alpha cos mulv3d addv3d /imageJ defpoint3d /imageI defpoint3d } { %% length = 4 aload pop /alpha exch def normalize3d /normal_vect defpoint3d normal_vect -1 0 0 eqp3d { /imageI {0 -1 0} def /imageK {-1 0 0} def /imageJ {0 0 1} def } { %% on calcule l image de la base (I,J,K) /imageJ {normal_vect 1 0 0 vectprod3d normalize3d} def /imageK {normal_vect} def /imageI {imageJ imageK vectprod3d} def 1 0 0 imageK angle3d 0 eq { 0 1 0 normal_vect vectprod3d /imageI defpoint3d /imageJ {0 1 0} def normal_vect /imageK defpoint3d } if } ifelse } ifelse %% et ensuite, on fait tourner la base autour de imageK imageI alpha cos mulv3d imageJ alpha sin mulv3d addv3d imageI alpha sin neg mulv3d imageJ alpha cos mulv3d addv3d /imageJ defpoint3d /imageI defpoint3d } ifelse } ifelse imageI imageJ imageK end } def %%%%% ### projpath ### %% syntaxe : x y z [normal] projpath --> planprojpath %% syntaxe : x y z [normal] bool projpath --> planprojpath %% syntaxe : solid i projpath --> solidprojpath %% syntaxe : solid i bool projpath --> solidprojpath %% syntaxe : solid i str bool projpath --> solidprojpath %% syntaxe : solid i alpha str bool projpath --> solidprojpath /projpath { 2 dict begin dup isbool { /mybool exch def } { /mybool true def } ifelse dup isplan { 3 dict begin /lepl@n exch def lepl@n plangetbase aload pop /@V defpoint3d /@U defpoint3d lepl@n plangetorigine [@U @U @V vectprod3d] mybool planprojpath end } { dup isarray { mybool planprojpath } { mybool solidprojpath } ifelse } ifelse end } def %% %% syntaxe : x y z [normal] projpath --> planprojpath %% %% syntaxe : x y z [normal] bool projpath --> planprojpath %% %% syntaxe : solid i projpath --> solidprojpath %% %% syntaxe : solid i bool projpath --> solidprojpath %% %% syntaxe : solid i str bool projpath --> solidprojpath %% %% syntaxe : solid i alpha str bool projpath --> solidprojpath %% /projpath { %% 2 dict begin %% dup isbool { %% /mybool exch def %% } { %% /mybool true def %% } ifelse %% dup isarray { %% mybool planprojpath %% } { %% mybool solidprojpath %% } ifelse %% end %% } def %% %% syntaxe : solid i str bool solidprojpath --> - %% ou %% syntaxe : solid i alpha str bool solidprojpath --> - %% projette le chemin courant sur la face i du solide, apres %% eventuellement une rotation d angle alpha autour de la normale %% bool : pour savoir si on tient compte de la visibilite /solidprojpath { 5 dict begin /visibility exch def dup isstring { /option exch def } if 2 copy pop issolid { /alpha 0 def } { /alpha exch def } ifelse /i exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidprojpath) == } if /n solid solidnombrefaces def i n 1 sub le { visibility not solid i solidfacevisible? or { currentdict /option known { option cvx exec } { solid i solidcentreface } ifelse [ solid 0 i solidgetsommetface solid 1 i solidgetsommetface vecteur3d normalize3d solid i solidnormaleface alpha ] false planprojpath } { newpath 0 0 smoveto } ifelse } { (Error : indice trop grand dans solidprojpath) == quit } ifelse end } def %% syntaxe : x y z [normal] bool planprojpath /planprojpath { 6 dict begin /visibility exch def %% on calcule l image de la base (I,J,K) normalvect_to_orthobase /imageK defpoint3d /imageJ defpoint3d /imageI defpoint3d /z exch def /y exch def /x exch def visibility not x y z imageK planvisible? or { {ptojpoint 0 imageI imageJ imageK transformpoint3d x y z addv3d 3dto2d jtoppoint} currentppathtransform } { newpath } ifelse end } def %%%%% ### projscene ### %% syntaxe : plantype bool bprojscene ... eprojscene /bprojscene { 10 dict begin gsave dup isbool { /mybool exch def } { /mybool true def } ifelse /l@pl@n exch def /savestroke {SolidesDict /stroke get exec} def /stroke {l@pl@n mybool projpath savestroke} def /savefill {SolidesDict /fill get exec} def /fill {l@pl@n mybool projpath savefill} def /masque {} def l@pl@n plangetrange aload pop setyrange setxrange newpath %% xmin ymin l@pl@n pointplan smoveto %% xmin ymax l@pl@n pointplan slineto %% xmax ymax l@pl@n pointplan slineto %% xmax ymin l@pl@n pointplan slineto %% xmin ymin l@pl@n pointplan smoveto %% % closepath %% %gsave orange fill grestore %% clip } def /eprojscene { grestore end } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% fonctions numeriques %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### courbeparam ### /setresolution { /resolution exch def } def /resolution 200 def /courbe_dic 2 dict def courbe_dic /X {} put courbe_dic /Y {} put %% syntaxe : tmin tmax C@urbeparam_ /C@urbeparam_ { 6 dict begin /tmax@ exch def /tmin@ exch def /t tmin@ def /dt tmax@ tmin@ sub resolution 1 sub div def tmin@ courbe_dic /X get exec pstrickactionR tmin@ courbe_dic /Y get exec pstrickactionR smoveto resolution 1 sub { t courbe_dic /X get exec pstrickactionR t courbe_dic /Y get exec pstrickactionR slineto /t t dt add store %% on incremente } repeat tmax@ courbe_dic /X get exec pstrickactionR tmax@ courbe_dic /Y get exec pstrickactionR slineto end } def %% syntaxe : tmin tmax {X} {Y} Courbeparam_ /Courbeparam_ { courbe_dic exch /Y exch put courbe_dic exch /X exch put C@urbeparam_ } def %% syntaxe : {X} {Y} courbeparam_ /courbeparam_ { tmin tmax 4 -1 roll 4 -1 roll Courbeparam_ } def %% syntaxe : tmin tmax {X} {Y} Courbeparam /Courbeparam { gsave 6 dict begin dup isstring { /option exch def } if courbe_dic exch /Y exch put courbe_dic exch /X exch put /tmax exch def /tmin exch def newpath tmin courbe_dic /X get exec pstrickactionR tmin courbe_dic /Y get exec pstrickactionR smoveto %% on commence le chemin tmin tmax C@urbeparam_ starfill stockcurrentcpath newarrowpath currentdict /option known { /dt tmax tmin sub resolution 1 sub div def tmin dt add courbe_dic /X get exec tmin dt add courbe_dic /Y get exec tmin courbe_dic /X get exec tmin courbe_dic /Y get exec arrowpath0 tmax dt sub courbe_dic /X get exec tmax dt sub courbe_dic /Y get exec tmax courbe_dic /X get exec tmax courbe_dic /Y get exec currentdict /dt undef arrowpath1 option gere_arrowhead } if currentlinewidth 0 eq {} {stroke} ifelse end grestore } def %% syntaxe : {X} {Y} courbeparam /courbeparam { dup isstring { tmin tmax 5 -1 roll 5 -1 roll 5 -1 roll } { tmin tmax 4 -1 roll 4 -1 roll } ifelse Courbeparam } def %% syntaxe : tmin tmax {X} {Y} Courbeparam* /Courbeparam* { 1 dict begin /startest {true} def Courbeparam end } def %% syntaxe : {X} {Y} courbeparam* /courbeparam* { 1 dict begin /startest {true} def courbeparam end } def %%%%% ### courbe ### %% syntaxe : {f} courbe /courbe { dup isstring %% y a-t-il une option de fin de ligne ? { xmin xmax {} 5 -1 roll 5 -1 roll } { xmin xmax {} 4 -1 roll } ifelse Courbeparam } def %% syntaxe : mini maxi {f} Courbe /Courbe { dup isstring { {} 3 -1 roll 3 -1 roll } { {} 2 -1 roll } ifelse Courbeparam } def %% syntaxe : {f} courbe_ /courbe_ { xmin xmax {} 4 -1 roll Courbeparam_ } def %% syntaxe : mini maxi {f} Courbe_ /Courbe_ { {} 2 -1 roll Courbeparam_ } def %% syntaxe : mini maxi {f} Courbe* /Courbe* { 1 dict begin /startest {true} def Courbe end } def %% syntaxe : {f} courbe* /courbe* { 1 dict begin /startest {true} def courbe end } def %%%%% ### courbeR2 ### %% syntaxe : tmin tmax C@urbeR2_ /C@urbeR2_ { 6 dict begin /tmax@ exch def /tmin@ exch def /t tmin@ def /dt tmax@ tmin@ sub resolution 1 sub div def tmin@ courbe_dic /X get exec pstrickactionR2 smoveto /t t dt add store resolution 2 sub { t courbe_dic /X get exec pstrickactionR2 slineto /t t dt add store %% on incremente } repeat tmax@ courbe_dic /X get exec pstrickactionR2 slineto end } def %% syntaxe : tmin tmax {X} CourbeR2_ /CourbeR2_ { courbe_dic exch /X exch put C@urbeR2_ } def %% syntaxe : {X} courbeR2_ /courbeR2_ { tmin tmax 3 -1 roll 3 -1 roll CourbeR2_ } def %% syntaxe : tmin tmax {X} CourbeR2 /CourbeR2+ { 2 dict begin /slineto {} def /smoveto {} def CourbeR2 end } bind def /CourbeR2 { gsave 6 dict begin dup isstring { /option exch def } if courbe_dic exch /X exch put /tmax exch def /tmin exch def newpath tmin tmax C@urbeR2_ starfill currentlinewidth 0 eq {} {stroke} ifelse end grestore } def %% syntaxe : {X} courbeR2 /courbeR2 { tmin tmax 3 -1 roll CourbeR2 } def %% syntaxe : tmin tmax {X} CourbeR2* /CourbeR2* { 1 dict begin /startest {true} def CourbeR2 end } def %% syntaxe : {X} {Y} courbeR2* /courbeR2* { 1 dict begin /startest {true} def courbeR2 end } def %%%%% ### courbeR3 ### %% syntaxe : t1 t2 {f} (option) CourbeR3 /CourbeR3 { 2 dict begin dup isstring { /option exch def } if /lafonction exch def {lafonction 3dto2d} currentdict /option known {option} if CourbeR2 end } def %% syntaxe : {f} (option) CourbeR3 /courbeR3 { tmin tmax 3 -1 roll CourbeR3 } def %%%%% ### cercle ### %% syntaxe : x0 y0 r cercle /cercle { 3 dict begin /r@y@n exch def /y@ exch def /x@ exch def 0 360 {cos r@y@n mul x@ add} {sin r@y@n mul y@ add} Courbeparam end } def %% syntaxe : x0 y0 r cercle_ /cercle_ { 3 dict begin /r@y@n exch def /y@ exch def /x@ exch def x@ r@y@n add y@ smoveto 0 360 {cos r@y@n mul x@ add} {sin r@y@n mul y@ add} Courbeparam_ end } def %% syntaxe : x0 y0 r cercle-_ /cercle-_ { 3 dict begin /r@y@n exch def /y@ exch def /x@ exch def x@ r@y@n add y@ smoveto 360 0 {cos r@y@n mul x@ add} {sin r@y@n mul y@ add} Courbeparam_ end } def %% syntaxe : x0 y0 r cercle* /cercle* { 1 dict begin /startest true def cercle end } def %% syntaxe : alpha beta x0 y0 r Cercle /Cercle { 4 dict begin dup isstring {/option exch def} if /r@y@n exch def /y@ exch def /x@ exch def {cos r@y@n mul x@ add} {sin r@y@n mul y@ add} currentdict /option known {option} if Courbeparam end } def %% syntaxe : alpha beta x0 y0 r Cercle_ /Cercle_ { 3 dict begin /r@y@n exch def /y@ exch def /x@ exch def {cos r@y@n mul x@ add} {sin r@y@n mul y@ add} Courbeparam_ end } def %% syntaxe : alpha beta x0 y0 r Cercle /Cercle* { 1 dict begin /startest {true} def Cercle end } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% fonctions et constantes mathematiques %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### math ### %%%%%%%%%%% constantes mathematiques %%%%%%%%%%%%%% /pi 3.14159 def /e 2.71828 def %%%%%%%%%%% fonctions mathematiques %%%%%%%%%%%%%%% /rd {180 pi div mul} def %% transforme des rd en degres /deg {pi mul 180 div} def %% transforme des degres en rd /log {ln 10 ln div} def /Exp {e exch exp} def /Cos {rd cos} def /Sin {rd sin} def /tan {dup sin exch cos div} def /cotan {dup cos exch sin div} def /Tan {dup Sin exch Cos div} def /Cotan {dup Cos exch Sin div} def /coTan {Cotan} def /arctan { dup 0 ge {1 atan} {neg 1 atan neg} ifelse } def /Arctan {arctan deg} def /arccos { dup dup mul neg 1 add sqrt exch atan } def /Arccos {arccos deg} def /arcsin { dup 1 eq { 90 } { dup dup mul neg 1 add sqrt atan dup 90 lt {} {360 sub} ifelse } ifelse } def /Arcsin {arcsin deg} def /cosh {dup Exp exch neg Exp add 2 div} def /sinh {dup Exp exch neg Exp sub 2 div} def /tanh {dup sinh exch cosh div} def /cotanh {dup cosh exch sinh div} def /argcosh {dup dup mul 1 sub sqrt add ln} def /argsinh {dup dup mul 1 add sqrt add ln} def /argtanh { setxvar x 1 add 1 x sub div ln 2 div } def /factorielle { dup 0 eq {pop 1} {dup 1 sub factorielle mul} ifelse } def /Gauss { 3 dict begin /sigma exch def /m exch def /x exch def x m sub dup mul sigma dup mul 2 mul div neg Exp 2 pi mul sigma dup mul mul sqrt div end } def %% syntaxe : a n modulo /modulo { 2 dict begin /n exch def /a exch def { a 0 lt { /a a n add store } { exit } ifelse } loop a n mod end } def %%%%% ### max ### /max { 2 copy lt {exch} if pop } def %%%%% ### min ### /min { 2 dict begin dup isarray { duparray /table exch def pop table 0 get 1 1 table length 1 sub { /i exch def table i get min } for } { 2 copy gt {exch} if pop } ifelse end } def %%%%% ### setcolor ### %% syntaxe : tableau setcolor /setcolor { dup length 4 eq {aload pop setcmykcolor} {aload pop setrgbcolor} ifelse } def %%%%% ### in ### %% cherche si un elt donne appartient au tableau donne %% rque : utilise 3 variables locales %% syntaxe : elt array in --> index boolean /in { 3 dict begin /liste exch def /elt exch def /i 0 def false %% la reponse a priori liste length { liste i get elt eq { pop %% en enleve la reponse i true %% pour mettre la bonne exit } if /i i 1 add store } repeat end } def %% cherche si un elt donne appartient au tableau donne %% syntaxe : elt array in --> boolean /In { 3 dict begin /liste exch def /elt exch def /i 0 def false %% la reponse a priori liste length { liste i get elt eq { pop %% en enleve la reponse true %% pour mettre la bonne exit } if /i i 1 add store } repeat end } def %%%%% ### starfill ### %% la procedure pour les objets "star" %% si c est "star" on fait le fillstyle, sinon non /starfill { startest { gsave clip fillstyle grestore /startest false def } if } def %%%%% ### addv ### %% syntaxe : u v addv --> u+v /addv { %% xA yA xB yB 3 1 roll %% xA yB yA xB 4 1 roll %% xB xA yB yA add 3 1 roll %% yB+yA xB xA add exch } def %%%%% ### continu ### /continu { [] 0 setdash } def %%%%% ### trigospherique ### %% passage spherique --> cartesiennes %% les formules de passage ont été récupérées ici : %% http://fr.wikipedia.org/wiki/Coordonn%C3%A9es_polaires %% syntaxe : r theta phi rtp2xyz -> x y z /rtp2xyz { 6 dict begin /phi exch def /theta exch def /r exch def /x phi cos theta cos mul r mul def /y phi cos theta sin mul r mul def /z phi sin r mul def x y z end } def %% trace d'un arc sur une sphere de centre O %% syntaxe : r theta1 phi1 r theta2 phi2 arcspherique /arcspherique { 9 dict begin dup isstring { /option exch def } if /phi2 exch def /theta2 exch def pop /phi1 exch def /theta1 exch def /r exch def /n 12 def 1 theta1 phi1 rtp2xyz /u defpoint3d 1 theta2 phi2 rtp2xyz /v defpoint3d u v vectprod3d u vectprod3d dupp3d norme3d 1 exch div mulv3d /w defpoint3d /sinalpha u v vectprod3d norme3d def /cosalpha u v scalprod3d def /alpha sinalpha cosalpha atan def /n 12 def /pas alpha n div def gsave /t pas neg def [ n 1 add { /t t pas add store u t cos r mul mulv3d w t sin r mul mulv3d addv3d } repeat ] currentdict /option known { option } if ligne3d grestore end } def %% trace d'un arc sur une sphere de centre O %% syntaxe : r theta1 phi1 r theta2 phi2 arcspherique /arcspherique_ { 8 dict begin /phi2 exch def /theta2 exch def pop /phi1 exch def /theta1 exch def /r exch def /n 12 def 1 theta1 phi1 rtp2xyz /u defpoint3d 1 theta2 phi2 rtp2xyz /v defpoint3d u v vectprod3d u vectprod3d dupp3d norme3d 1 exch div mulv3d /w defpoint3d /sinalpha u v vectprod3d norme3d def /cosalpha u v scalprod3d def /alpha sinalpha cosalpha atan def /n 12 def /pas alpha n div def /t pas neg def [ n 1 add { /t t pas add store u t cos r mul mulv3d w t sin r mul mulv3d addv3d } repeat ] ligne3d_ end } def %% trace d'une geodesique sur une sphere de centre O %% syntaxe : r theta1 phi1 r theta2 phi2 geodesique_sphere /geodesique_sphere { 13 dict begin /phi2 exch def /theta2 exch def pop /phi1 exch def /theta1 exch def /r exch def /n 360 def 1 theta1 phi1 rtp2xyz /u defpoint3d 1 theta2 phi2 rtp2xyz /v defpoint3d u v vectprod3d u vectprod3d dupp3d norme3d 1 exch div mulv3d /w defpoint3d /sinalpha u v vectprod3d norme3d def /cosalpha u v scalprod3d def /alpha sinalpha cosalpha atan def /pas 360 n div def gsave /t pas neg def [ n 1 add { /t t pas add store u t cos r mul mulv3d w t sin r mul mulv3d addv3d } repeat ] ligne3d grestore end } def %% syntaxe : A B C trianglespherique --> trace le rtiangle ABC %% (coordonnees spheriques) /trianglespherique* { 1 dict begin /startest {true} def trianglespherique end } def /trianglespherique { 10 dict begin /C defpoint3d /B defpoint3d /A defpoint3d gsave newpath A rtp2xyz 3dto2d smoveto A B arcspherique_ B C arcspherique_ C A arcspherique_ closepath starfill currentlinewidth 0 eq {} {stroke} ifelse grestore end } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% operations sur les tableaux %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### duparray ### /duparray { 1 dict begin /table exch def table [ table aload pop ] end } def %%%%% ### append ### %% syntaxe : string1 string2 append --> concatene les 2 chaines ou fusionne 2 tableaux /append { 3 dict begin dup isarray { /tab2 exch def /tab1 exch def [ tab1 aload pop tab2 aload pop ] } { /str2 exch def /str1 exch def /result str1 length str2 length add string def str1 result copy pop result str1 length str2 putinterval result } ifelse end } def %%%%% ### rollparray ### %% syntaxe : array n rollparray -> array %% opere une rotation de n sur les couplets du tableau array /rollparray { 4 dict begin /k exch def /table exch def /n table length def k 0 eq { table } { k 0 ge { [ table aload pop 2 {n 1 roll} repeat ] k 1 sub } { [ table aload pop 2 {n -1 roll} repeat ] k 1 add } ifelse rollparray } ifelse end } def %%%%% ### bubblesort ### %% syntaxe : array bubblesort --> array2 trie par ordre croissant %% code de Bill Casselman %% http://www.math.ubc.ca/people/faculty/cass/graphics/text/www/ /bubblesort { 4 dict begin /a exch def /n a length 1 sub def n 0 gt { % at this point only the n+1 items in the bottom of a remain to % the sorted largest item in that blocks is to be moved up into % position n n { 0 1 n 1 sub { /i exch def a i get a i 1 add get gt { % if a[i] > a[i+1] swap a[i] and a[i+1] a i 1 add a i get a i a i 1 add get % set new a[i] = old a[i+1] put % set new a[i+1] = old a[i] put } if } for /n n 1 sub def } repeat } if a end } def %% syntaxe : array1 doublebubblesort --> array2 array3, array3 est %% trie par ordre croissant et array2 correspond a la position des %% indices de depart, ie si array1 = [3 2 4 1], alors array2 = [3 1 0 2] %% code de Bill Casselman, modifie par jpv, 15/08/2006 %% http://www.math.ubc.ca/people/faculty/cass/graphics/text/www/ /doublebubblesort { 5 dict begin /table exch def /n table length 1 sub def /indices [ 0 1 n {} for ] def n 0 gt { % at this point only the n+1 items in the bottom of a remain to % the sorted largest item in that blocks is to be moved up into % position n n { 0 1 n 1 sub { /i exch def table i get table i 1 add get gt { % if a[i] > a[i+1] swap a[i] and a[i+1] table i 1 add table i get table i table i 1 add get % set new a[i] = old a[i+1] put % set new a[i+1] = old a[i] put indices i 1 add indices i get indices i indices i 1 add get % set new a[i] = old a[i+1] put % set new a[i+1] = old a[i] put } if } for /n n 1 sub def } repeat } if indices table end } def %%%%% ### quicksort ### %% src : http://www.math.ubc.ca/~cass/graphics/text/www/code/sort.inc %% code de Bill Casselman, modifie par jpv, 18/10/2007 /qsortdict 8 dict def qsortdict begin % args: /comp a L R x % effect: effects a partition into two pieces [L j] [i R] % leaves i j on stack /partition { 8 dict begin /x exch def /j exch def /i exch def /a exch def load /comp exch def { { a i get x comp exec not { exit } if /i i 1 add def } loop { x a j get comp exec not { exit } if /j j 1 sub def } loop i j le { % swap a[i] a[j] a j a i get a i a j get put put indices j indices i get indices i indices j get put put /i i 1 add def /j j 1 sub def } if i j gt { exit } if } loop i j end } def % args: /comp a L R % effect: sorts a[L .. R] according to comp /subsort { % /c a L R [ 3 1 roll ] 3 copy % /c a [L R] /c a [L R] aload aload pop % /c a [L R] /c a L R L R add 2 idiv % /c a [L R] /c a L R (L+R)/2 3 index exch get % /c a [L R] /c a L R x partition % /c a [L R] i j % if j > L subsort(a, L, j) dup % /c a [L R] i j j 3 index 0 get gt { % /c a [L R] i j 5 copy % /c a [L R] i j /c a [L R] i j exch pop % /c a [L R] i j /c a [L R] j exch 0 get exch % ... /c a L j subsort } if % /c a [L R] i j pop dup % /c a [L R] i i % if i < R subsort(a, i, R) 2 index 1 get lt { % /c a [L R] i exch 1 get % /c a i R subsort }{ 4 { pop } repeat } ifelse } def end % args: /comp a % effect: sorts the array a % comp returns truth of x < y for entries in a /quicksort { qsortdict begin dup length 1 gt { % /comp a dup % /comp a a length 1 sub % /comp a n-1 0 exch subsort } { pop pop } ifelse end } def % ---------------------------------------- %% fin du code de Bill Casselman %% syntaxe : array1 doublebubblesort --> array2 array3, array3 est %% trie par ordre croissant et array2 correspond a la position des %% indices de depart, ie si array1 = [3 2 4 1], alors array2 = [3 1 0 2] %% code de Bill Casselman, modifie par jpv, 18/10/2007 %% http://www.math.ubc.ca/people/faculty/cass/graphics/text/www/ /doublequicksort { qsortdict begin /comp exch /a exch def a dup length /n exch def /indices [0 1 n 1 sub {} for ] def dup length 1 gt { % /comp a dup % /comp a a length 1 sub % /comp a n-1 0 exch subsort } { pop pop } ifelse indices a end } def /comp {lt} def %%%%% ### apply ### %% syntaxe : [x1 ... xn] (f) apply --> [f(x1) ... f(xn)] /apply { 3 dict begin dup isstring {/fonction exch cvx def} {/fonction exch def} ifelse /liste exch def /@i 0 def [ liste length { liste @i get fonction /@i @i 1 add store } repeat counttomark 0 eq {pop} {]} ifelse end } def %% syntaxe : [x1 ... xn] (f) papply /papply { 3 dict begin dup isstring {/fonction exch cvx def} {/fonction exch def} ifelse /liste exch def /@i 0 def [ liste length 2 idiv { liste @i get liste @i 1 add get fonction /@i @i 2 add store } repeat counttomark 0 eq {pop} {]} ifelse end } def %% syntaxe : [x1 ... xn] (f) capply /capply { 3 dict begin dup isstring {/fonction exch cvx def} {/fonction exch def} ifelse /liste exch def /@i 0 def [ liste length 3 idiv { liste @i get liste @i 1 add get liste @i 2 add get fonction /@i @i 3 add store } repeat counttomark 0 eq {pop} {]} ifelse end } def %%%%% ### reverse ### %% syntaxe : array reverse --> inverse l ordre des items dans %% le tableau /reverse { 3 dict begin /le_tableau exch def /n le_tableau length def /i n 1 sub def [ n { le_tableau i get /i i 1 sub store } repeat ] end } def %% syntaxe : array_points reversep --> inverse l ordre des points dans %% le tableau /reversep { 3 dict begin /le_tableau exch def /n le_tableau length 2 idiv def /i n 1 sub def [ n { le_tableau i getp /i i 1 sub store } repeat ] end } def %%%%% ### get ### %% syntaxe : array_points n getp --> le n-ieme point du tableau de %% points array_points /getp { 2 copy 2 mul get 3 1 roll 2 mul 1 add get } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% matrices %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### linear ### %% syntaxe : M i j any --> depose any dans M en a_ij /put_ij { 5 dict begin /a exch def /j exch def /i exch def /M exch def /L M i get_Li def L j a put M i L put_Li end } def %% syntaxe : M i j get_ij --> le coeff c_ij /get_ij { 3 1 roll %% j M i get_Li %% j L_i exch get } def %% syntaxe : M i L put_Li --> remplace dans M la ligne Li par L /put_Li { put } def %% syntaxe : M i get_Li --> la ligne Li de M /get_Li { get } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% geometrie 3d (calculs) %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### sortp3d ### /sortp3d { 6 dict begin /M1 defpoint3d /M0 defpoint3d M1 /z1 exch def /y1 exch def /x1 exch def M0 /z0 exch def /y0 exch def /x0 exch def x0 x1 lt { M0 M1 } { x0 x1 gt { M1 M0 } { y0 y1 lt { M0 M1 } { y0 y1 gt { M1 M0 } { z0 z1 lt { M0 M1 } { M1 M0 } ifelse } ifelse } ifelse } ifelse } ifelse end } def %%%%% ### dupp3d ### %% duplique le vecteur 3d /dupp3d { %% x y z 3 copy } def /dupv3d {dupp3d} def %%%%% ### angle3d ### %% syntaxe : vect1 vect2 angle3d /angle3d { 4 dict begin normalize3d /vect2 defpoint3d normalize3d /vect1 defpoint3d /cosalpha vect1 vect2 scalprod3d def /sinalpha vect1 vect2 vectprod3d norme3d def sinalpha cosalpha atan end } def %%%%% ### transformpoint3d ### %% syntaxe : x y z a11 a21 a31 a12 a22 a32 a13 a23 a33 %% transformpoint3d -> X Y Z /transformpoint3d { 12 dict begin /a33 exch def /a23 exch def /a13 exch def /a32 exch def /a22 exch def /a12 exch def /a31 exch def /a21 exch def /a11 exch def /z exch def /y exch def /x exch def a11 x mul a12 y mul add a13 z mul add a21 x mul a22 y mul add a23 z mul add a31 x mul a32 y mul add a33 z mul add end } def %%%%% ### normalize3d ### %% rend le vecteur 3d unitaire. Ne fait rien si u=0 /unitaire3d { %% x y z 2 dict begin /u defpoint3d /norme u norme3d def norme 0 eq { u } { u 1 norme div mulv3d } ifelse end } def /normalize3d {unitaire3d} def %%%%% ### geom3d ### %% syntaxe : A k1 B k2 barycentre3d -> G, barycentre du systeme %% [(A, k1) (B, k2)] /barycentre3d { 4 dict begin /k2 exch def /B defpoint3d /k1 exch def /A defpoint3d A k1 mulv3d B k2 mulv3d addv3d 1 k1 k2 add div mulv3d end } def %% syntaxe : array isobarycentre3d --> G /isobarycentre3d { 2 dict begin /table exch def /n table length 3 idiv def table 0 getp3d 1 1 n 1 sub { table exch getp3d addv3d } for 1 n div mulv3d end } def %% syntaxe : M A alpha hompoint3d -> le point M' tel que AM' = alpha AM /hompoint3d { 3 dict begin /alpha exch def /A defpoint3d /M defpoint3d A M vecteur3d alpha mulv3d A addv3d end } def %% syntaxe : M A sympoint3d -> le point M' tel que AM' = -AM /sympoint3d { 2 dict begin /A defpoint3d /M defpoint3d A M vecteur3d -1 mulv3d A addv3d end } def %% syntaxe : A u translatepoint3d --> B image de A par la translation de vecteur u /translatepoint3d { addv3d } def /scaleOpoint3d { 6 dict begin /k3 exch def /k2 exch def /k1 exch def /z exch def /y exch def /x exch def k1 x mul k2 y mul k3 z mul end } def % syntaxe : M alpha_x alpha_y alpha_z rotateOpoint3d --> M' /rotateOpoint3d { 21 dict begin /RotZ exch def /RotY exch def /RotX exch def /Zpoint exch def /Ypoint exch def /Xpoint exch def /c1 {RotX cos} bind def /c2 {RotY cos} bind def /c3 {RotZ cos} bind def /s1 {RotX sin} bind def /s2 {RotY sin} bind def /s3 {RotZ sin} bind def /M11 {c2 c3 mul} bind def /M12 {c3 s1 mul s2 mul c1 s3 mul sub} bind def /M13 {c1 c3 mul s2 mul s1 s3 mul add} bind def /M21 {c2 s3 mul} bind def /M22 {s1 s2 mul s3 mul c1 c3 mul add} bind def /M23 {s3 s2 mul c1 mul c3 s1 mul sub} bind def /M31 {s2 neg} bind def /M32 {s1 c2 mul} bind def /M33 {c1 c2 mul} bind def M11 Xpoint mul M12 Ypoint mul add M13 Zpoint mul add M21 Xpoint mul M22 Ypoint mul add M23 Zpoint mul add M31 Xpoint mul M32 Ypoint mul add M33 Zpoint mul add end } def %%%%% ### symplan3d ### %% syntaxe : M eqplan/plantype symplan3d --> M' %% ou M' symetrique de M par rapport au plan P defini par eqplan/plantype /symplan3d { 13 dict begin dup isplan { plan2eq /args exch def } { /args exch def } ifelse /z exch def /y exch def /x exch def args aload pop /d1 exch def /c1 exch def /b1 exch def /a1 exch def /n_U a1 dup mul b1 dup mul add c1 dup mul add sqrt def /a a1 n_U div def /b b1 n_U div def /c c1 n_U div def /d d1 n_U div def /u a x mul b y mul add c z mul add d add def x 2 a mul u mul sub y 2 b mul u mul sub z 2 c mul u mul sub end } def %%%%% ### vecteur3d ### %% creation du vecteur AB a partir de A et B /vecteur3d { %% xA yA zA xB yB zB 6 dict begin /zB exch def /yB exch def /xB exch def /zA exch def /yA exch def /xA exch def xB xA sub yB yA sub zB zA sub end }def %%%%% ### vectprod3d ### %% produit vectoriel de deux vecteurs 3d /vectprod3d { %% x1 y1 z1 x2 y2 z2 6 dict begin /zp exch def /yp exch def /xp exch def /z exch def /y exch def /x exch def y zp mul z yp mul sub z xp mul x zp mul sub x yp mul y xp mul sub end } def %%%%% ### scalprod3d ### %% produit scalaire de deux vecteurs 3d /scalprod3d { %% x1 y1 z1 x2 y2 z2 6 dict begin /zp exch def /yp exch def /xp exch def /z exch def /y exch def /x exch def x xp mul y yp mul add z zp mul add end } def %%%%% ### papply3d ### %% syntaxe : [A1 ... An] (f) papply3d --> [f(A1) ... f(An)] /papply3d { 3 dict begin /fonction exch def /liste exch def /i 0 def [ liste length 3 idiv { liste i get liste i 1 add get liste i 2 add get fonction /i i 3 add store } repeat counttomark 0 eq {pop} {]} ifelse end } def %%%%% ### defpoint3d ### %% creation du point A a partir de xA yA yB et du nom /A /defpoint3d { %% xA yA zA /nom 1 dict begin /memo exch def [ 4 1 roll ] cvx memo exch end def }def %%%%% ### distance3d ### /distance3d { %% A B vecteur3d norme3d } def %%%%% ### get3d ### /getp3d { %% [tableau de points 3d] i --> donne le ieme point du tableau 2 copy 2 copy 3 mul get 5 1 roll 3 mul 1 add get 3 1 roll 3 mul 2 add get } def %%%%% ### norme3d ### %% norme d un vecteur 3d /norme3d { %% x y z 3 dict begin /z exch def /y exch def /x exch def x dup mul y dup mul add z dup mul add sqrt end } def %%%%% ### mulv3d ### %% (scalaire)*(vecteur 3d) Attention : dans l autre sens ! /mulv3d { %% x y z lambda 4 dict begin /lambda exch def /z exch def /y exch def /x exch def x lambda mul y lambda mul z lambda mul end } def %%%%% ### addv3d ### %% addition de deux vecteurs 3d /addv3d { %% x1 y1 z1 x2 y2 z2 6 dict begin /zp exch def /yp exch def /xp exch def /z exch def /y exch def /x exch def x xp add y yp add z zp add end } def %%%%% ### milieu3d ### /milieu3d { %% A B --> I le milieu de [AB] addv3d 0.5 mulv3d } def %%%%% ### exch ### /exchp { 4 -1 roll 4 -1 roll } def /exchc { 6 -1 roll 6 -1 roll 6 -1 roll } def /exchd { 4 {8 -1 roll} repeat } def /exchp3d { 6 -1 roll 6 -1 roll 6 -1 roll } def %%%%% ### ABpoint3d ### %% syntaxe : A B k ABpoint3d --> M %% M tel que vect(AM) = k vect (AB) /ABpoint3d { 3 dict begin /k exch def /B defpoint3d /A defpoint3d A B vecteur3d k mulv3d A addv3d end } def %%%%% ### angle3doriente ### %% syntaxe : vect1 vect2 vect3 angle3d %% vect3 est la normale au plan (vect1, vect2) /angle3doriente { 4 dict begin normalize3d /vect3 defpoint3d normalize3d /vect2 defpoint3d normalize3d /vect1 defpoint3d /cosalpha vect1 vect2 scalprod3d def /sinalpha vect1 vect2 vectprod3d vect3 scalprod3d def sinalpha cosalpha atan end } def %%%%% ### points3dalignes ### %% syntaxe : A B C points3dalignes -> bool /points3dalignes { 3 dict begin /C defpoint3d /B defpoint3d /A defpoint3d A B vecteur3d /u defpoint3d A C vecteur3d /v defpoint3d u v vectprod3d norme3d 1E-7 lt end } def %% syntaxe : M A B point3dsursegment --> true si M in [AB], false sinon /point3dsursegment { 3 dict begin /B defpoint3d /A defpoint3d /M defpoint3d M A B points3dalignes { M A vecteur3d M B vecteur3d scalprod3d 0 lt { true } { false } ifelse } { false } ifelse end } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% geometrie 3d (dessins) %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### point3d ### /point3d { %% A 3dto2d point } def /points3d { %% tableau de points3d tab3dto2d points } def %%%%% ### ligne3d ### %% [tableau de points3d] option --> trace la ligne brisee /ligne3d { 1 dict begin dup isstring {/option exch def} if tab3dto2d currentdict /option known {option} if ligne end } def %% [tableau de points3d] option --> trace la ligne brisee /ligne3d_ { 1 dict begin dup isstring {/option exch def} if tab3dto2d currentdict /option known {option} if ligne_ end } def %%%%% ### tab3dto2d ### %% transforme un tableau de points 3d en tableau de points 2d /tab3dto2d { 2 dict begin /T exch def /n T length def [ T aload pop n 1 sub -1 n 3 idiv 2 mul { 1 dict begin /i exch def 3dto2d i 2 roll end } for ] end } def %%%%% ### polygone3d ### /polygone3d { %% tableau de points3d tab3dto2d polygone } def /polygone3d* { %% tableau de points3d tab3dto2d polygone* } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% gestion du texte %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### marks ### /xmkstep 1 def % les marques sur Ox /xmarkstyle {dctext} def /ymarkstyle {(-1 0) bltext} def /setxmkstep { /xmkstep exch def } def /xmark { dup xtick /Courier findfont .8 fontsize mul scalefont setfont dup dup truncate eq { cvi dup chaine cvs exch } { dup chaine cvs exch } ifelse Oy xmarkstyle } def /xmarks { 2 dict begin /n xmax xmax xmin sub 1000 div sub xmkstep div truncate cvi xmkstep mul def % mark max /i xmin xmkstep div truncate cvi xmkstep mul def % la 1ere i xmin lt {/i i xmkstep add store} if { i 0 ne {i xmark} if /i i xmkstep abs add store i n gt {exit} if } loop end } def /ymkstep 1 def % les marques sur Oy /setymkstep { /ymkstep exch def } def /ymark { dup ytick /Courier findfont .8 fontsize mul scalefont setfont dup chaine cvs exch Ox exch ymarkstyle } def /ymarks { 2 dict begin /n ymax ymax ymin sub 1000 div sub ymkstep div truncate cvi ymkstep mul def % mark max /i ymin ymkstep div truncate cvi ymkstep mul def % la 1ere { i 0 ne {i ymark} if /i i ymkstep abs add store i n gt {exit} if } loop end } def /setmkstep { setymkstep setxmkstep } def /marks { xmarks ymarks } def %%%%% ### setfontsize ### /setfontsize { /fontsize exch def } def %%%%% ### setCourrier ### /Courier findfont dup length dict begin { 1 index /FID ne {def} {pop pop} ifelse } forall /Encoding ISOLatin1Encoding def currentdict end /Courier-ISOLatin1 exch definefont pop /setCourier { /Courier-ISOLatin1 findfont fontsize scalefont setfont } def %%%%% ### pathtext ### %% syntaxe : string x y initp@thtext /initp@thtext { 7 dict begin /y exch def /x exch def /str exch def str 0 0 show_dim /wy exch def /wx exch def /lly exch def /llx exch def pop pop pop newpath x y smoveto } def /closep@thtext { str true charpath end } def %% syntaxe : string x y cctext_ /cctext_ { initp@thtext llx wx add lly wy add -.5 mulv rmoveto closep@thtext } def /brtext_ { initp@thtext hadjust 0 rmoveto llx neg 0 rmoveto closep@thtext } def /bbtext_ { initp@thtext 0 0 rmoveto 0 0 rmoveto closep@thtext } def /bltext_ { initp@thtext hadjust neg 0 rmoveto wx neg 0 rmoveto closep@thtext } def /bctext_ { initp@thtext 0 0 rmoveto wx llx add -.5 mul 0 rmoveto closep@thtext } def /ubtext_ { initp@thtext 0 vadjust rmoveto 0 lly neg rmoveto closep@thtext } def /urtext_ { initp@thtext hadjust vadjust rmoveto llx neg lly neg rmoveto closep@thtext } def /ultext_ { initp@thtext hadjust neg vadjust rmoveto wx neg lly neg rmoveto closep@thtext } def /uctext_ { initp@thtext 0 vadjust rmoveto llx wx add -.5 mul lly neg rmoveto closep@thtext } def /drtext_ { initp@thtext hadjust vadjust neg rmoveto llx neg wy neg rmoveto closep@thtext } def /dbtext_ { initp@thtext 0 vadjust neg rmoveto 0 wy neg rmoveto closep@thtext } def /dltext_ { initp@thtext hadjust neg vadjust neg rmoveto wx neg wy neg rmoveto closep@thtext } def /dctext_ { initp@thtext 0 vadjust neg rmoveto llx wx add -2 div wy neg rmoveto closep@thtext } def /crtext_ { initp@thtext hadjust 0 rmoveto llx neg lly wy add -2 div rmoveto closep@thtext } def /cbtext_ { initp@thtext 0 0 rmoveto 0 lly wy add -2 div rmoveto closep@thtext } def /cltext_ { initp@thtext hadjust neg 0 rmoveto wx neg lly wy add -2 div rmoveto closep@thtext } def /cctext_ { initp@thtext 0 0 rmoveto llx wx add lly wy add -.5 mulv rmoveto closep@thtext } def %%%%% ### text3d ### %%%% Version 3d des commandes jps TEXTE /pr@p@re3d { 2 dict begin % /vect_echelle [1 1] def % /angle_de_rot {0} def % dup xcheck % {/angle_de_rot exch def} % if % dup isarray % {/vect_echelle exch def} % if% CamView vect_echelle {angle_de_rot} 3dto2d } def /bbtext3d { pr@p@re3d bbtext end } def /bbtexlabel3d { pr@p@re3d bbtexlabel end } def /bctext3d { pr@p@re3d bctext end } def /bctexlabel3d { pr@p@re3d bctexlabel end } def /bltext3d { pr@p@re3d bltext end } def /bltexlabel3d { pr@p@re3d bltexlabel end } def /brtext3d { pr@p@re3d brtext end } def /brtexlabel3d { pr@p@re3d brtexlabel end } def /cbtext3d { pr@p@re3d cbtext end } def /cbtexlabel3d { pr@p@re3d cbtexlabel end } def /cctext3d { pr@p@re3d cctext end } def /cctexlabel3d { pr@p@re3d cctexlabel end } def /cltext3d { pr@p@re3d cltext end } def /cltexlabel3d { pr@p@re3d cltexlabel end } def /crtext3d { pr@p@re3d crtext end } def /crtexlabel3d { pr@p@re3d crtexlabel end } def /dbtext3d { pr@p@re3d dbtext end } def /dbtexlabel3d { pr@p@re3d dbtexlabel end } def /dctext3d { pr@p@re3d dctext end } def /dctexlabel3d { pr@p@re3d dctexlabel end } def /dltext3d { pr@p@re3d dltext end } def /dltexlabel3d { pr@p@re3d dltexlabel end } def /drtext3d { pr@p@re3d drtext end } def /drtexlabel3d { pr@p@re3d drtexlabel end } def /ubtext3d { pr@p@re3d ubtext end } def /ubtexlabel3d { pr@p@re3d ubtexlabel end } def /uctext3d { pr@p@re3d uctext end } def /uctexlabel3d { pr@p@re3d uctexlabel end } def /ultext3d { pr@p@re3d ultext end } def /ultexlabel3d { pr@p@re3d ultexlabel end } def /urtext3d { pr@p@re3d urtext end } def /urtexlabel3d { pr@p@re3d urtexlabel end } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% bibliotheque sur les solides %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### solide ### %% solid = [Sommets Faces Colors_Faces InOut_Table] /solidgetsommets { 0 get } def /solidgetpointstable {solidgetsommets} def /solidgetfaces { 1 get } def /solidgetface { 1 dict begin /i exch def solidgetfaces i get end } def /solidgetfcolors { 2 get } def %% syntaxe : solid i solidgetfcolor --> str /solidgetfcolor { 1 dict begin /i exch def solidgetfcolors i get end } def %% syntaxe : solid i str solidputfcolor --> - /solidputfcolor { 2 dict begin /str exch def /i exch def solidgetfcolors i str put end } def /solidgetinouttable { 3 get } def /solidputsommets { 0 exch put } def /solidputpointstable {solidputsommets} def /solidputfaces { 1 exch put } def %% syntaxe : solid solidfacesreverse -> - /solidfacesreverse { 5 dict begin /solid exch def /n solid solidnombrefaces def 0 1 n 1 sub { /i exch def /F solid i solidgetface reverse def /m F length def solid i [F aload pop m 0 roll ] solidputface } for end } def /solidputfcolors { 2 exch put } def /solidputinouttable { 3 exch put } def %% syntaxe : any issolid --> booleen, vrai si any est de type solid /issolid { 1 dict begin /candidat exch def candidat isarray { candidat length 4 eq { candidat 0 get isarray candidat 1 get isarray and candidat 2 get isarray and candidat 3 get isarray and { /IO candidat 3 get def IO length 4 eq IO 0 get isnum and IO 1 get isnum and IO 2 get isnum and IO 3 get isnum and } { false } ifelse } { false } ifelse } { false } ifelse end } def /dupsolid { 5 dict begin /solid exch def /S solid solidgetsommets def /F solid solidgetfaces def /FC solid solidgetfcolors def /IO solid solidgetinouttable def solid [ S duparray exch pop F duparray exch pop FC duparray exch pop IO duparray exch pop ] end } def %% syntaxe : solid array solidputinfaces --> - /solidputinfaces { 4 dict begin /facesinternes exch def /solid exch def /n2 facesinternes length def /IO solid solidgetinouttable def /facesexternes solid solidgetoutfaces def /n1 facesexternes length def solid [facesexternes aload pop facesinternes aload pop] solidputfaces IO 0 0 put IO 1 n1 1 sub put IO 2 n1 put IO 3 n1 n2 add 1 sub put end } def %% syntaxe : solid array solidputoutfaces --> - /solidputoutfaces { 4 dict begin /facesexternes exch def /solid exch def /n1 facesexternes length def /IO solid solidgetinouttable def /facesinternes solid solidgetinfaces def /n2 facesinternes length def solid [facesexternes aload pop facesinternes aload pop] solidputfaces IO 0 0 put IO 1 n1 1 sub put IO 2 n1 put IO 3 n1 n2 add 1 sub put end } def /solidnombreinfaces { 1 dict begin /solid exch def solid solidwithinfaces { /IO solid solidgetinouttable def IO 3 get IO 2 get sub 1 add } { 0 } ifelse end } def /solidnombreoutfaces { 1 dict begin /solid exch def /IO solid solidgetinouttable def IO 1 get IO 0 get sub 1 add end } def %% syntaxe : solid solidgetinfaces --> array /solidgetinfaces { 4 dict begin /solid exch def solid issolid not { (Error : mauvais type d argument dans solidgetinfaces) == quit } if solid solidwithinfaces { /IO solid solidgetinouttable def /F solid solidgetfaces def /n1 IO 2 get def /n2 IO 3 get def /n n2 n1 sub 1 add def F n1 n getinterval } { [] } ifelse end } def %% syntaxe : solid solidgetoutfaces --> array /solidgetoutfaces { 4 dict begin /solid exch def solid issolid not { (Error : mauvais type d argument dans solidgetoutfaces) == quit } if /IO solid solidgetinouttable def /F solid solidgetfaces def /n1 IO 0 get def /n2 IO 1 get def /n n2 n1 sub 1 add def F n1 n getinterval end } def %% /tracelignedeniveau? false def %% /hauteurlignedeniveau 1 def %% /couleurlignedeniveau {rouge} def %% /linewidthlignedeniveau 4 def /solidgridOn { /solidgrid true def } def /solidgridOff { /solidgrid false def } def %% syntaxe : solid i string solidputfcolor %% syntaxe : solid str outputcolors %% syntaxe : solid str1 str2 inoutputcolors %% syntaxe : solid string n solidputncolors %% syntaxe : solid array solidputincolors --> - %% syntaxe : solid array solidputoutcolors --> - %% syntaxe : solid solidgetincolors --> array %% syntaxe : solid solidgetoutcolors --> array %% syntaxe : solid array solidputinfaces --> - %% syntaxe : solid array solidputoutfaces --> - %% syntaxe : solid solidgetinfaces --> array %% syntaxe : solid solidgetoutfaces --> array %% syntaxe : solid1 solid2 solidfuz -> solid %% syntaxe : solid i solidgetsommetsface -> array %% array = tableau de points 3d /solidgetsommetsface { 1 dict begin /i exch def /solid exch def /F solid i solidgetface def [ 0 1 F length 1 sub { /k exch def solid F k get solidgetsommet } for ] end } def %% syntaxe : solid index table solidputface -> - /solidputface { 1 dict begin /table exch def /i exch def solidgetfaces i table put end } def %% syntaxe : solid table solidaddface -> - %% syntaxe : solid table (couleur) solidaddface -> - %% on ne se preoccupe pas des faces internes /solidaddface { 6 dict begin dup isstring { /lac@uleur exch def } { /lac@uleur () def } ifelse /table exch def /solid exch def /IO solid solidgetinouttable def /n2 IO 1 get def /FC solid solidgetoutcolors def IO 1 n2 1 add put solid [ solid solidgetfaces aload pop table ] solidputfaces solid IO solidputinouttable % solid solidnombrefaces solid [ FC aload pop lac@uleur ] solidputoutcolors end } def /solidnombrefaces { 1 dict begin /solid exch def solid solidnombreinfaces solid solidnombreoutfaces add end } def %% syntaxe : solid M solidaddsommetexterne -> - %% on ajoute le sommet sans se preoccuper de rien /solidaddsommetexterne { 2 dict begin /M defpoint3d /solid exch def solid [ solid solidgetsommets aload pop M ] solidputsommets end } def %% syntaxe : solid array solidaddsommets -> - /solidaddsommets { 2 dict begin /table exch def /solid exch def /n table length 3 idiv def 0 1 0 { /i exch def solid table i getp3d solidaddsommet pop } for end } def %% syntaxe : solid M solidaddsommet -> k %% on ajoute le sommet M. Si il est deja sur une arete, %% on l incorpore a la face concernee %% s il est deja present, on ne le rajoute pas. %% Renvoie l indice du sommet rajoute. /solidaddsommet { 10 dict begin /M defpoint3d /solid exch def /nbf solid solidnombrefaces def /N solid solidnombresommets def /sortie -1 def %% le sommet est-il deja dans la structure 0 1 N 1 sub { /i exch def %% (addsommet) == %% solid i solidgetsommet == == == %% M == == == %% solid i solidgetsommet M eqp3d == % solid i solidgetsommet M eqp3d { solid i solidgetsommet M distance3d 1e-5 le { %% oui => c est fini /sortie i store } if } for sortie 0 lt { %% non => on le rajoute /sortie N def solid M solidaddsommetexterne %% est il sur une arete deja codee 0 1 nbf 1 sub { %% face d indice i /i exch def solid i solidgetface /F exch def /nbsf F length def 0 1 nbsf 1 sub { /j exch def M solid j i solidgetsommetface solid j 1 add nbsf mod i solidgetsommetface point3dsursegment { %% il est sur l arete concernee solid i [ 0 1 j { /k exch def F k get } for N j 1 add nbsf mod dup 0 eq { pop } { 1 nbsf 1 sub { /k exch def F k get } for } ifelse ] solidputface exit } if } for } for } if sortie end } def %%%%% ### solidrmsommet ### %% syntaxe : solid i solidrmsommet -> - /solidrmsommet { 5 dict begin /i exch def /solid exch def solid issolid not { (Erreur : mauvais type d argument dans solidrmsommet) == quit } if solid i solidsommetsadjsommet length 0 gt { (Erreur : sommet non isole dans solidrmsommet) == quit } if %% on s occupe des sommets /n solid solidnombresommets def /S [ 0 1 n 1 sub { /j exch def j i ne { solid j solidgetsommet } if } for ] def solid S solidputsommets %% on s occupe des faces /n solid solidnombrefaces def /F [ 0 1 n 1 sub { %% face d indice j /j exch def /Fj solid j solidgetface def [0 1 Fj length 1 sub { %% sommet d indice k de la face Fj /k exch def Fj k get dup i gt { 1 sub } if } for] } for ] def solid F solidputfaces end } def %%%%% ### solidsommetsadjsommet ### %% syntaxe : solid i solidsommetsadjsommet --> array %% array est le tableau des indices des sommets adjacents au %% sommet d indice i /solidsommetsadjsommet { 6 dict begin /no exch def /solid exch def solid no solidfacesadjsommet /facesadj exch def /sommetsadj [] def /nbadj facesadj length def 0 1 nbadj 1 sub { /j exch def %% examen de la jieme face %/j 0 def /F solid facesadj j get solidgetface def /nbsommetsface F length def no F in { /index exch def /i1 F index 1 sub nbsommetsface modulo get def /i2 F index 1 add nbsommetsface mod get def %% si i1 n est pas deja note, on le rajoute i1 sommetsadj in { pop } { /sommetsadj [ sommetsadj aload pop i1 ] store } ifelse %% si i2 n est pas deja note, on le rajoute i2 sommetsadj in { pop } { /sommetsadj [ sommetsadj aload pop i2 ] store } ifelse } { (Error : bug dans solidsommetsadjsommet) == quit } ifelse } for sommetsadj end } def %%%%% ### solidfacesadjsommet ### %% syntaxe : solid i solidfacesadjsommet --> array %% array est le tableau des indices des faces adjacentes au %% sommet d indice i /solidfacesadjsommet { 6 dict begin /no exch def /solid exch def /n solid solidnombrefaces def /indicesfacesadj [] def 0 1 n 1 sub { /j exch def /F solid j solidgetface def no F in { pop /indicesfacesadj [ indicesfacesadj aload pop j ] store } if } for indicesfacesadj end } def %%%%% ### ordonnepoints3d ### %% syntaxe : array1 M ordonnepoints3d --> array2 %% array1 = tableau de points 3d coplanaires (plan P) %% M = point3d indiquant la direction de la normale a P %% array2 = les indices des points de depart, ranges dans le %% sens trigo par rapport a la normale /ordonnepoints3d { 5 dict begin /M defpoint3d /table exch def table isobarycentre3d /G defpoint3d %% calcul de la normale table 0 getp3d /ptref defpoint3d table 1 getp3d /A defpoint3d G ptref vecteur3d G A vecteur3d vectprod3d /vecteurnormal defpoint3d vecteurnormal G M vecteur3d scalprod3d 0 lt { vecteurnormal -1 mulv3d /vecteurnormal defpoint3d } if %% la table des angles table duparray exch pop {1 dict begin /M defpoint3d G ptref vecteur3d G M vecteur3d vecteurnormal angle3doriente end} papply3d % [0 1 table length 3 idiv 1 sub {} for] % exch doublebubblesort pop end } def %%%%% ### fin insertion ### %% /tracelignedeniveau? false def %% /hauteurlignedeniveau 1 def %% /couleurlignedeniveau {rouge} def %% /linewidthlignedeniveau 4 def %% %% /solidgrid true def %% /aretescachees true def %% /defaultsolidmode 2 def %% syntaxe : alpha beta r h newpie --> solid /newpie { 6 dict begin [[/resolution /nbetages] [8 1] [10 1] [12 1] [18 3] [36 5]] gestionsolidmode /h exch def /r exch def /beta exch def /alpha exch def [ 0 0 % alpha cos r mul alpha sin r mul alpha beta {1 dict begin /t exch def t cos r mul t sin r mul end} CourbeR2+ ] 0 h [nbetages] newprismedroit end } def %%%%% ### newsolid ### %% syntaxe : newsolid --> depose le solide nul sur la pile /newsolid { [] [] generesolid } def %%%%% ### generesolid ### /generesolid { 2 dict begin /F exch def /S exch def [S F [F length {()} repeat] [0 F length 1 sub -1 -1]] end } def %%%%% ### nullsolid ### %% syntaxe : solide nullsolid -> booleen, vrai si le solide est nul /nullsolid { 1 dict begin /candidat exch def candidat issolid not { (Error type argument dans "nullsolid") == quit } if candidat solidgetsommets length 0 eq { true } { false } ifelse end } def %%%%% ### solidnombreoutfaces ### /solidnombreoutfaces { 4 dict begin /solid exch def solid issolid not { (Error : mauvais type d argument dans solidnombreoutfaces) == quit } if solid nullsolid { 0 } { /IO solid solidgetinouttable def IO 1 get IO 0 get sub 1 add } ifelse end } def %%%%% ### solidnombreinfaces ### /solidnombreinfaces { 4 dict begin /solid exch def solid issolid not { (Error : mauvais type d argument dans solidnombreinfaces) == quit } if solid solidwithinfaces { /IO solid solidgetinouttable def IO 3 get IO 2 get sub 1 add } { 0 } ifelse end } def %%%%% ### solidtests ### %% syntaxe : solid solidwithinfaces --> bool, true si le solide est vide /solidwithinfaces { 2 dict begin /solid exch def solid issolid not { (Error : mauvais type d argument dans solidwithinfaces) == quit } if /table solid solidgetinouttable def table 2 get -1 ne { true } { false } ifelse end } def %%%%% ### solidgetsommet ### %% syntaxe : solid i j solidgetsommetface --> sommet i de la face j /solidgetsommetface { 6 dict begin /j exch def /i exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidgetsommetface) == quit } if /table_faces solid solidgetfaces def /table_sommets solid solidgetsommets def /k table_faces j get i get def table_sommets k getp3d end } def %% syntaxe : solid i solidgetsommetsface --> array, tableau des %% sommets de la face i du solide /solidgetsommetsface { 6 dict begin /i exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidgetsommetsface) == quit } if /table_faces solid solidgetfaces def /table_sommets solid solidgetsommets def /table_indices table_faces i get def [ 0 1 table_indices length 1 sub { /j exch def table_sommets table_indices j get getp3d } for ] end } def %% syntaxe : solid i solidgetsommet --> sommet i du solide /solidgetsommet { 3 dict begin /i exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidgetsommet) == quit } if /table_sommets solid solidgetsommets def table_sommets i getp3d end } def %%%%% ### solidcentreface ### %% syntaxe : solid i solidcentreface --> M /solidcentreface { solidgetsommetsface isobarycentre3d } def %%%%% ### solidnombre ### /solidnombresommets { solidgetsommets length 3 idiv } def /solidfacenombresommets { solidgetface length } def /solidnombrefaces { solidgetfaces length } def %%%%% ### solidshowsommets ### /solidshowsommets { 8 dict begin dup issolid not { %% on a un argument /option exch def } if /sol exch def /n sol solidnombresommets def /m sol solidnombrefaces def currentdict /option known not { /option [0 1 n 1 sub {} for] def } if 0 1 option length 1 sub { /k exch def option k get /i exch def %% indice du sommet examine sol i solidgetsommet point3d } for end } def %%%%% ### solidnumsommets ### /solidnumsommets { 8 dict begin Font findfont 10 scalefont setfont dup issolid not { %% on a un argument /option exch def } if /sol exch def /n sol solidnombresommets def /m sol solidnombrefaces def currentdict /option known not { /option [0 1 n 1 sub {} for] def } if /result [ n {false} repeat ] def 0 1 option length 1 sub { /k exch def option k get /i exch def %% indice du sommet examine 0 1 m 1 sub { /j exch def %% indice de la face examinee i sol j solidgetface in { %% le sommet i est dans la face j pop exit } if } for %% le sommet i est dans la face j sol j solidcentreface /G defpoint3d sol i solidgetsommet /S defpoint3d i ( ) cvs G S vecteur3d normalize3d 15 dup ptojpoint pop mulv3d S addv3d 3dto2d cctext } for end } def %%%%% ### gestionsolidmode ### %% table = [ [vars] [mode0] [mode1] [mode2] [mode3] [mode4] ] /gestionsolidmode { 5 dict begin /table exch def dup xcheck { /mode exch def } { dup isarray { /tableaffectation exch def /mode -1 def } { /mode defaultsolidmode def } ifelse } ifelse /vars table 0 get def /nbvars vars length def mode 0 ge { /tableaffectation table mode 1 add 5 min get def } if 0 1 nbvars 1 sub { /i exch def vars i get tableaffectation i get } for nbvars end {def} repeat } def %%%%% ### solidfuz ### %% syntaxe : solid1 solid2 solidfuz -> solid /solidfuz { 5 dict begin /solid2 exch def /solid1 exch def /S1 solid1 solidgetsommets def /S2 solid2 solidgetsommets def /n S1 length 3 idiv def %% les sommets /S S1 S2 append def %% les faces internes et leurs couleurs /FI1 solid1 solidgetinfaces def /FIC1 solid1 solidgetincolors def solid2 solidnombreinfaces 0 eq { /FI2 [] def /FIC2 [] def } { /FI2 solid2 solidgetinfaces {{n add} apply} apply def /FIC2 solid2 solidgetincolors def } ifelse /FI [FI1 aload pop FI2 aload pop] def /FIC [FIC1 aload pop FIC2 aload pop] def %% les faces externes et leurs couleurs /FO1 solid1 solidgetoutfaces def /FOC1 solid1 solidgetoutcolors def /FO2 solid2 solidgetoutfaces {{n add} apply} apply def /FOC2 solid2 solidgetoutcolors def /FO [FO1 aload pop FO2 aload pop] def /FOC [FOC1 aload pop FOC2 aload pop] def /F [FO aload pop FI aload pop] def /FC [FOC aload pop FIC aload pop] def /IO [ 0 FO length 1 sub FI length 0 gt { dup 1 add dup FI length add 1 sub } { -1 -1 } ifelse ] def S F generesolid dup FC solidputfcolors dup IO solidputinouttable end } def %%%%% ### solidnormaleface ### %% syntaxe : solid i solidnormaleface --> u, vecteur normale a la %% face d indice i du solide /solidnormaleface { 4 dict begin /i exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidgetsommetface) == quit } if %% solid 0 i solidgetsommetface /G defpoint3d %% G %% solid 1 i solidgetsommetface %% vecteur3d %% G %% solid 2 i solidgetsommetface %% vecteur3d /n solid i solidfacenombresommets def solid i solidcentreface /G defpoint3d %% debug %% G 3dto2d point G solid 0 i solidgetsommetface /A defpoint3d % gsave bleu A point3d grestore A vecteur3d normalize3d G solid 1 i solidgetsommetface /A defpoint3d % gsave orange A point3d grestore A vecteur3d normalize3d vectprod3d /resultat defpoint3d resultat normalize3d end } def %%%%% ### solidtransform ### %% syntaxe : solid1 {f} solidtransform --> solid2, solid2 est le %% transforme de solid1 par la transformation f : R^3 -> R^3 /solidtransform { 3 dict begin /@f exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidtransform) == quit } if /les_sommets solid solidgetsommets {@f} papply3d def solid les_sommets solidputsommets solid end } def %%%%% ### solidputcolor ### %% syntaxe : solid i string solidputfcolor /solidputfcolor { 3 dict begin /str exch def /i exch def /solid exch def /FC solid solidgetfcolors def i FC length lt { FC i str put } if end } def %% syntaxe : solid solidgetincolors --> array /solidgetincolors { 3 dict begin /solid exch def solid issolid not { (Error : mauvais type d argument dans solidgetincolors) == quit } if solid solidwithinfaces { /fcol solid solidgetfcolors def /IO solid solidgetinouttable def /n1 IO 2 get def /n2 IO 3 get def /n n2 n1 sub 1 add def fcol n1 n getinterval } { [] } ifelse end } def %% syntaxe : solid solidgetoutcolors --> array /solidgetoutcolors { 3 dict begin /solid exch def solid issolid not { (Error : mauvais type d argument dans solidgetoutcolors) == quit } if /fcol solid solidgetfcolors def /IO solid solidgetinouttable def /n1 IO 0 get def /n2 IO 1 get def /n n2 n1 sub 1 add def fcol n1 n getinterval end } def %% syntaxe : solid array solidputincolors --> - /solidputincolors { 4 dict begin /newcolorstable exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidputincolors) == quit } if /n newcolorstable length def n solid solidnombreinfaces ne { (Error : mauvaise longueur de tableau dans solidputincolors) == quit } if n 0 ne { /FC solid solidgetfcolors def /IO solid solidgetinouttable def /n1 IO 2 get def FC n1 newcolorstable putinterval } if end } def %% syntaxe : solid array solidputoutcolors --> - /solidputoutcolors { 4 dict begin /newcolorstable exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidputoutcolors) == quit } if /n newcolorstable length def n solid solidnombreoutfaces ne { (Error : mauvaise longueur de tableau dans solidputoutcolors) == quit } if n 0 ne { /FC solid solidgetfcolors def /IO solid solidgetinouttable def /n1 IO 0 get def FC n1 newcolorstable putinterval } if end } def %% syntaxe : solid str outputcolors /outputcolors { 5 dict begin /color exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans inoutputcolors) == quit } if /n solid solidnombreoutfaces def solid [ n {color} repeat ] solidputoutcolors end } def %% syntaxe : solid str inputcolors /inputcolors { 5 dict begin /color exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans inoutputcolors) == quit } if /n solid solidnombreinfaces def solid [ n {color} repeat ] solidputincolors end } def %% syntaxe : solid str1 str2 inoutputcolors /inoutputcolors { 5 dict begin /colout exch def /colin exch def /solid exch def solid colin inputcolors solid colout outputcolors end } def %% syntaxe : solid array solidputoutcolors --> - /solidputoutcolors { 4 dict begin /newcolorstable exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidputoutcolors) == quit } if /n newcolorstable length def n solid solidnombreoutfaces ne { (Error : mauvaise longueur de tableau dans solidputoutcolors) == quit } if n 0 ne { /FC solid solidgetfcolors def /IO solid solidgetinouttable def /n1 IO 0 get def FC length n n1 add lt { solid newcolorstable solidputfcolors } { FC n1 newcolorstable putinterval } ifelse } if end } def /solidputcolors { 3 dict begin 2 copy pop isstring { inoutputcolors } { outputcolors } ifelse end } def %%%%% ### solidputhuecolors ### %% syntaxe : solid table solidputhuecolors --> - /solidputhuecolors { 1 dict begin 2 copy pop solidgetinouttable /IO exch def IO 0 get IO 1 get s@lidputhuec@l@rs end } def /solidputinhuecolors { 2 dict begin /table exch def /solid exch def solid solidgetinouttable /IO exch def solid solidwithinfaces { solid table IO 2 get IO 3 get s@lidputhuec@l@rs } if end } def /solidputinouthuecolors { 1 dict begin 2 copy pop solidgetinouttable /IO exch def IO 0 get IO 3 get IO 1 get max s@lidputhuec@l@rs end } def %% syntaxe : solid table n1 n2 s@lidputhuec@l@rs --> - %% affecte les couleurs des faces d indice n1 a n2 du solid solid, par %% un degrade defini par la table. /s@lidputhuec@l@rs { 9 dict begin /n2 exch def /n1 exch def /table exch def /solid exch def /n n2 n1 sub def table length 2 eq { /a0 table 0 get def /a1 table 1 get def a1 isstring { /lacouleurdepart { gsave [a0 cvx exec] length 0 eq { a0 cvx exec currentrgbcolor } { a0 cvx exec } ifelse grestore } def /lacouleurarrivee { gsave [a1 cvx exec] length 0 eq { a1 cvx exec currentrgbcolor } { a1 cvx exec } ifelse grestore } def /table [lacouleurdepart lacouleurarrivee] def } { /A {a0 i a1 a0 sub mul n 1 sub div add} def /B {1} def /C {1} def /D {} def /espacedecouleurs (sethsbcolor) def } ifelse } if table length 4 eq { /a0 table 0 get def /a1 table 1 get def /A {a0 i a1 a0 sub mul n 1 sub div add} def /B table 2 get def /C table 3 get def /D {} def /espacedecouleurs (sethsbcolor) def } if table length 6 eq { /a0 table 0 get def /b0 table 1 get def /c0 table 2 get def /a1 table 3 get def /b1 table 4 get def /c1 table 5 get def /A {a0 i a1 a0 sub mul n 1 sub div add} def /B {b0 i b1 b0 sub mul n 1 sub div add} def /C {c0 i c1 c0 sub mul n 1 sub div add} def /D {} def /espacedecouleurs (setrgbcolor) def } if table length 7 eq { /a0 table 0 get def /b0 table 1 get def /c0 table 2 get def /a1 table 3 get def /b1 table 4 get def /c1 table 5 get def /A {a0 i a1 a0 sub mul n 1 sub div add} def /B {b0 i b1 b0 sub mul n 1 sub div add} def /C {c0 i c1 c0 sub mul n 1 sub div add} def /D {} def /espacedecouleurs (sethsbcolor) def } if table length 8 eq { /a0 table 0 get def /b0 table 1 get def /c0 table 2 get def /d0 table 3 get def /a1 table 4 get def /b1 table 5 get def /c1 table 6 get def /d1 table 7 get def /A {a0 i a1 a0 sub mul n 1 sub div add} def /B {b0 i b1 b0 sub mul n 1 sub div add} def /C {c0 i c1 c0 sub mul n 1 sub div add} def /D {d0 i d1 d0 sub mul n 1 sub div add} def /espacedecouleurs (setcmykcolor) def } if n1 1 n2 { /i exch def solid i [A B C D] espacedecouleurs astr2str solidputfcolor } for end } def %%%%% ### solidrmface ### %% syntaxe : solid i solidrmface -> - /solidrmface { 5 dict begin /i exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidrmface) == quit } if %% on enleve la face /F solid solidgetfaces def F length 1 sub i lt { (Error : indice trop grand dans solidrmface) == quit } if [ 0 1 F length 1 sub { /j exch def i j ne { F j get } if } for ] /NF exch def solid NF solidputfaces %% on enleve la couleur correspondante /FC solid solidgetfcolors def [ 0 1 FC length 1 sub { /j exch def i j ne { FC j get } if } for ] /NFC exch def solid NFC solidputfcolors %% on ajuste la table inout /IO solid solidgetinouttable def solid i solidisoutface { IO 1 IO 1 get 1 sub put solid solidwithinfaces { IO 2 IO 2 get 1 sub put IO 3 IO 3 get 1 sub put } if } if solid i solidisinface { IO 1 IO 1 get 1 sub put IO 2 IO 2 get 1 sub put IO 3 IO 3 get 1 sub put } if solid IO solidputinouttable end } def %% syntaxe : solid table solidrmfaces --> - /solidrmfaces { 2 dict begin /table exch bubblesort reverse def /solid exch def table {solid exch solidrmface} apply end } def %%%%% ### videsolid ### %% syntaxe : solid videsolid -> - /videsolid { 5 dict begin /solid exch def solid issolid not { (Error : mauvais type d argument dans videsolid) == quit } if solid solidwithinfaces not { /IO solid solidgetinouttable def /FE solid solidgetfaces def /n FE length def IO 2 n put IO 3 2 n mul 1 sub put solid IO solidputinouttable %% on inverse chaque face /FI FE {reverse} apply def solid FE FI append solidputfaces %% et on rajoute autant de couleurs vides que de faces /FEC solid solidgetfcolors def % /FIC [FI length {()} repeat] def % solid FEC FIC append solidputfcolors solid FEC duparray append solidputfcolors } if end } def %%%%% ### solidnumfaces ### %% syntaxe : solid array solidnumfaces %% syntaxe : solid array bool solidnumfaces %% array, le tableau des indices des faces a numeroter, est optionnel %% si bool=true, on ne numerote que les faces visibles /solidnumfaces { 5 dict begin dup isbool { /bool exch def } { /bool true def } ifelse setTimes dup issolid not { %% on a un argument /option exch def } if /sol exch def /n sol solidnombrefaces def currentdict /option known not { /option [0 1 n 1 sub {} for] def } if 0 1 option length 1 sub { /i exch def /j option i get def j ( ) cvs sol j bool cctextp3d } for end } def %%%%% ### creusesolid ### %% syntaxe : solid creusesolid -> - /creusesolid { 5 dict begin /solid exch def solid issolid not { (Error : mauvais type d argument dans creusesolid) == quit } if %% on enleve le fond et le chapeau solid 1 solidrmface solid 0 solidrmface %% on inverse chaque face solid videsolid end } def %%%%% ### fin insertion ### %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%% dessin des solides %%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%% ### solidisinface ### %% syntaxe : solid i solidisinface --> bool %% true si i est l indice d une face interne, false sinon /solidisinface { 4 dict begin /i exch def solidgetinouttable /IO exch def /n1 IO 2 get def /n2 IO 3 get def n1 i le i n2 le and end } def %%%%% ### solidisoutface ### %% syntaxe : solid i solidisoutface --> bool %% true si i est l indice d une face externe, false sinon /solidisoutface { 4 dict begin /i exch def solidgetinouttable /IO exch def /n1 IO 0 get def /n2 IO 1 get def n1 i le i n2 le and end } def %%%%% ### planvisible ### %% syntaxe : A k planvisible? --> true si le plan est visible /planvisible? { 4 dict begin /normale_plan defpoint3d /origine defpoint3d /ligne_de_vue { origine GetCamPos vecteur3d } def ligne_de_vue normale_plan scalprod3d 0 gt end } def %%%%% ### solidlight ### /setlightintensity { /lightintensity exch def } def /setlightsrc { /lightsrc defpoint3d } def /setlight { 1 dict begin gsave exec [ currentrgbcolor ] /lightcolor exch grestore end def } def %%%%% ### drawsolid ### /solidlightOn { /s@lidlight true def } def /solidlightOff { /s@lidlight false def } def solidlightOff %% syntaxe : solid i solidfacevisible? --> true si la face est visible /solidfacevisible? { 4 dict begin /i exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans solidgetsommetface) == quit } if solid i solidgetface length 2 le { true } { /ligne_de_vue { solid i solidcentreface GetCamPos vecteur3d } def /normale_face { solid i solidnormaleface } def ligne_de_vue normale_face scalprod3d 0 gt } ifelse end } def %% syntaxe : solid i affectecouleursolid_facei --> si la couleur de %% la face i est definie, affecte fillstyle a cette couleur /affectecouleursolid_facei { 3 dict begin /i exch def /solid exch def solid solidgetfcolors /FC exch def FC length 1 sub i ge { FC i get length 1 ge { /fillstyle FC i get ( fill) append cvx solidgrid not { FC i get cvx exec } if true } { false } ifelse } { false } ifelse end {def} if } def %% syntaxe : solid i dessinefacecachee /dessinefacecachee { 11 dict begin /i exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans dessinefacecachee) == quit } if /F solid solidgetfaces def /S solid solidgetsommets def %% face cachee => on prend chacune des aretes de la face et on %% la dessine 4 dict begin /n F i get length def %% nb de sommets de la face 0 1 n 1 sub { /k exch def /k1 F i k get_ij def %% indice sommet1 /k2 F i k 1 add n mod get_ij def %% indice sommet2 gsave currentlinewidth .5 mul setlinewidth pointilles [S k1 getp3d S k2 getp3d sortp3d] ligne3d grestore } for %% trace de la ligne de niveau solidintersectiontype 0 ge { /face_a_dessiner [ %% face visible : F [i] 0 1 n 1 sub { /j exch def solid j i solidgetsommetface } for ] def 0 1 solidintersectionplan length 1 sub { /k exch def /lignedeniveau [] def gsave pointilles k solidintersectionlinewidth length lt { solidintersectionlinewidth k get setlinewidth } { solidintersectionlinewidth 0 get setlinewidth } ifelse k solidintersectioncolor length lt { solidintersectioncolor k get cvx exec } { solidintersectioncolor 0 get cvx exec } ifelse 0 1 n 1 sub { /j exch def face_a_dessiner j getp3d face_a_dessiner j 1 add n mod getp3d solidintersectionplan k get dup isarray { segment_inter_plan } { segment_inter_planz } ifelse { 1 dict begin /table exch def table length 6 eq { /lignedeniveau table store exit } { /lignedeniveau [ lignedeniveau aload pop table 0 getp3d ] store } ifelse end } if } for %% dessin de la ligne lignedeniveau length 4 ge { [lignedeniveau aload pop sortp3d] ligne3d } if grestore } for } if end end } def %% syntaxe : solid i dessinefacevisible /dessinefacevisible { 8 dict begin /i exch def /solid exch def solid issolid not { (Error : mauvais type d argument dans dessinefacevisible) == quit } if /F solid solidgetfaces def /S solid solidgetsommets def /n F i get length def %% nb de sommets de la face startest { s@lidlight { /coeff lightintensity solid i solidnormaleface normalize3d solid i solidcentreface lightsrc vecteur3d normalize3d scalprod3d mul 0 max 1 min def /lightcolor where { pop /lacouleur lightcolor def } { /lacouleur [ gsave solid solidgetfcolors i get cvx exec currentrgbcolor grestore ] def } ifelse /fillstyle { lacouleur {coeff mul} apply setcolor fill } def solidgrid not { lacouleur {coeff mul} apply setcolor } if } { n 2 eq { 1 dict begin solidgridOff solid i affectecouleursolid_facei end } { solid i affectecouleursolid_facei } ifelse } ifelse } if /face_a_dessiner [ %% face visible : F [i] 0 1 n 1 sub { /j exch def solid j i solidgetsommetface } for ] def face_a_dessiner polygone3d %% trace de la ligne de niveau solidintersectiontype 0 ge { 0 1 solidintersectionplan length 1 sub { /k exch def /lignedeniveau [] def gsave k solidintersectionlinewidth length lt { solidintersectionlinewidth k get setlinewidth } { solidintersectionlinewidth 0 get setlinewidth } ifelse k solidintersectioncolor length lt { solidintersectioncolor k get cvx exec } { solidintersectioncolor 0 get cvx exec } ifelse 0 1 n 1 sub { /j exch def face_a_dessiner j getp3d face_a_dessiner j 1 add n mod getp3d solidintersectionplan k get dup isarray { segment_inter_plan } { segment_inter_planz } ifelse { 1 dict begin /table exch def /lignedeniveau [ lignedeniveau aload pop table 0 getp3d table length 4 ge { table 1 getp3d } if ] store end } if } for %% dessin de la ligne lignedeniveau length 4 ge { solid i solidisinface { pointilles } if lignedeniveau ligne3d } if grestore } for } if end } def /drawsolid* { 1 dict begin /startest {true} def drawsolid end } def /peintrealgorithme false def /drawsolid** { 2 dict begin /aretescachees false def /peintrealgorithme true def drawsolid* end } def %% syntaxe : solid array drawsolid %% array est en option, il indique les faces triees /drawsolid { 8 dict begin dup issolid not { /ordre exch def } if /solid exch def solid issolid not { (Error : mauvais type d argument dans drawsolid) == quit } if solid nullsolid not { solid solidgetfaces /F exch def solid solidgetsommets /S exch def /n S length 3 idiv def currentdict /ordre known not { peintrealgorithme { %% tri des indices des faces par distance decroissante [ 0 1 F length 1 sub { /i exch def solid i solidcentreface GetCamPos distance3d } for ] doublequicksort pop reverse } { [ 0 1 F length 1 sub { } for ] } ifelse /ordre exch def } if 0 1 F length 1 sub { /k exch def /i ordre k get def gsave solid i solidfacevisible? { solid i dessinefacevisible } if grestore } for aretescachees { 0 1 F length 1 sub {