Le module geometry_dev est utilisé pour les fonctions parallel ainsi que pour les objets point et line. La définition négative de linemargin permet d'étendre les dimensions du cadre de la figure afin que les droites puissent se poursuivre au delà des points limites représentés sur cette figure. Très pratique.

unitsize(2cm);
import geometry_dev;
linemargin = -8mm;

point pO = (0,0);
point pN = (3,0);
point pM = (2,1.25);
point pN_1 = (5,0);
point pN_2 = (-4,0);

dot(Label("$O$",align=SE),pO);
dot(Label("$N$",align=NE),pN);
dot(Label("$M$",align=NE+2N),pM);
dot(Label("$N_1$",align=NE),pN_1);
dot(Label("$N_2$",align=NE),pN_2);

line d_prime = line(pO,pN);
line d = line(pO,pM);
line MN = line(pM,pN);

draw(Label("$(d')$",Relative(0),S),d_prime);
draw(Label("$(d)$",Relative(0),W),d);
draw(MN);

line MN_1 = parallel(pN_1,MN);
line MN_2 = parallel(pN_2,MN);

draw(MN_1);
draw(MN_2);

point pM_1 = intersectionpoint(d,MN_1);
point pM_2 = intersectionpoint(d,MN_2);

dot(Label("$M_1$",align=NE+2N),pM_1);
dot(Label("$M_2$",align=2.4E+0.4S),pM_2);

shipout(bbox(xmargin=1mm,invisible));

Le module geometry_dev est utilisé pour les fonctions markrightangle (qui permet de marque un angle droit) ainsi que pour les objets point et line. Ici la commande addMargins (voir ici)est utilisée pour étendre les dimensions de l'image comme on le souhaite afin de prolonger les droites tracées (objets line).

unitsize(2cm);
import geometry_dev;

point pO = (0,0);
point pA = (2,0);
point pB = (-5,0);
point pM = (2,1.5);

dot(Label("$O$",align=SE),pO);
dot(Label("$A$",align=SE),pA);
dot(Label("$B$",align=SW),pB);
dot(Label("$M$",align=SE),pM);

line AB = line(pA,pB);
line OM = line(pO,pM);
line AM = line(pA,pM);
line Bx = line(pB,pB+(0,1));

draw(AB);
draw(OM);
draw(AM);
draw(Bx);

markrightangle(pO,pB,pB+(0,1),blue);
markrightangle(pO,pA,pM,blue);

addMargins(2mm,4mm,2mm,6mm);
shipout(bbox(xmargin=1mm,invisible));

unitsize(1cm);
import geometry_dev;

real r = 3;

point pA = (0,0);
point pM = (-r,0);
point pT = (r,0);

point pS = rotate(-65,pA)*pM;
point pH = rotate(-110,pA)*pM;

dot(Label("$A$",align=S),pA);
dot(Label("$M$",align=SW),pM);
dot(Label("$T$",align=SE),pT);
dot(Label("$S$",align=NW),pS);
dot(Label("$H$",align=NE),pH);

draw(pM--pT,StickIntervalMarker(2,1,size=6,angle=-45,red));
draw(pM--pS--pT^^pM--pH--pT);
draw(pA--pS--pH--cycle,dashed);

markrightangle(pM,pS,pT,blue);
markrightangle(pM,pH,pT,blue);

shipout(bbox(xmargin=1mm,invisible));

Utilisation de la commande markangle qui permet de marquer et de légender des angles.

unitsize(1cm);
import geometry_dev;

real r = 3;
real a = 59;

point pO = (0,0);
point pN = (-r,0);
point pP = (r,0);

point pM = rotate(180-2*a,pO)*pP;

dot(Label("$O$",align=S),pO);
dot(Label("$N$",align=SW),pN);
dot(Label("$P$",align=SE),pP);
dot(Label("$M$",align=NE),pM);

draw(pN--pP,StickIntervalMarker(2,1,size=6,angle=-45,red));
draw(pO--pM,StickIntervalMarker(1,1,size=6,angle=-45,red));
draw(pN--pM--pP);

markangle(Label("$59^\circ$"),pM,pP,pN,radius=5mm,blue);
markangle(Label("$?$"),pP,pN,pM,radius=10mm,blue);

shipout(bbox(xmargin=1mm,invisible));

Utilisation de la structure segment et de la commande midpoint permettant de récupérer le milieu d'un segment.

unitsize(1cm);
import geometry_dev;
usepackage("mathrsfs");

point pB = (0,0);
point pA = (0,2);
point pM = (-3,0);
point pN = (2,0);

point pO = midpoint(segment(pA,pM));
point pO_prime = midpoint(segment(pA,pN));

draw(Label("$\mathscr{C}$",Relative(0.4)),circle(pA,pB,pM),grey);
draw(Label("$\mathscr{C}'$",Relative(0.15)),circle(pA,pB,pN),grey);

dot(Label("$B$",align=2S),pB);
dot(Label("$A$",align=2N),pA);
dot(Label("$M$",align=SW),pM);
dot(Label("$N$",align=SE),pN);
dot(Label("$O$",align=SE),pO);
dot(Label("$O'$",align=SE),pO_prime);

draw(pM--pA,StickIntervalMarker(2,1,size=6,angle=-45,red));
draw(pM--pN^^pA--pB);

shipout(bbox(xmargin=1mm,invisible));

Commande line avec les paramètres facultatifs false qui permet de représenter des demi-droites ou des segments. Utilisation également de la bien pratique commande interp et du linemargin négatif qui permet de prolonger un peu les droites au delà de la figure (ce qui augmente les dimensions de la figure).

unitsize(1.5cm);
import geometry_dev;
linemargin = -5mm;

point pB = (0,0);
point pC = (4,0);
point pA = (3,3);

line AB = line(pA,pB);
line BC = line(pB,false,pC,false);
line AC = line(pA,false,pC);

point pD = interp(pA,pB,0.75);
point pE = interp(pB,pC,0.6);
point pI = intersectionpoint(line(pA,pC),line(pD,pE));

dot(Label("$A$",align=NW),pA);
dot(Label("$B$",align=2W),pB);
dot(Label("$C$",align=2E),pC);
dot(Label("$D$",align=2N),pD);
dot(Label("$E$",align=2S),pE);
dot(Label("$I$",align=NE),pI);

draw(AB^^BC^^AC);
draw(line(pD,pE),dashed);

shipout(bbox(xmargin=1mm,invisible));

Attention, le module pifont doit être installé. Il permet d'obtenir les numéros entourés utilisés pour noter les angles.

unitsize(1cm);
import geometry_dev;
usepackage("pifont");

point pO = (0,0);
point pA = (2,0);
point pB = (5,0);
point pC = (3,3);

dot(Label("$O$",align=SW),pO);
dot(Label("$A$",align=S),pA);
dot(Label("$B$",align=S),pB);
dot(Label("$C$",align=NW),pC);

draw(Label("$x$",Relative(1),S),line(pO,false,pA));
draw(Label("$z$",Relative(1),SE),line(pO,false,pC));
draw(Label("$y$",Relative(1),SE),line(pB,false,pB+pC));
draw(pA--pC--pB);

markangle(Label("\ding{172}"),pA,pO,pC,radius=5mm,blue);
markangle(Label("\ding{173}"),pO,pA,pC,radius=3mm,blue);
markangle(Label("\ding{174}"),pA,pC,pO,radius=8mm,blue);
markangle(Label("\ding{175}"),pC,pA,pB,radius=5mm,blue);
markangle(Label("\ding{176}"),pC,pB,pA,radius=3mm,blue);
markangle(Label("\ding{177}"),pA,pC,pB,radius=4mm,blue);
markangle(Label("\ding{178}"),pB+(1,0),pB,pB+pC,radius=6mm,blue);

addMargins(0mm,0mm,45mm,15mm);
shipout(bbox(xmargin=1mm,invisible));

Utilisation de la routine rotatedLabel qui permet d'orienter un label le long d'un segment. Voir ici (figure 2) pour une version “à main levée” réalisée (et améliorée) par Ph. Ivaldi. Attention : la commande rotatedLabel n'est plus intégrée dans le module geometry_dev mais dans le module base_pi.

unitsize(1cm);
import geometry_dev;

point pA = (0,0);
point pB = (0,4);
point pC = intersectionpoints(line(pB,false,rotate(35,pB)*pA),circle(pB,6))[0];
point pD = intersectionpoints(line(pC,false,rotate(-112,pC)*pB),circle(pC,4))[0];
point pE = intersectionpoints(line(pD,false,rotate(-78,pD)*pC),circle(pD,4))[0];
point pFi = rotate(35,pE)*pD;

dot(Label("$A$",align=SE),pA);
dot(Label("$B$",align=NW),pB);
dot(Label("$C$",align=SW),pC);
dot(Label("$D$",align=SE),pD);
dot(Label("$E$",align=NW),pE);

line l1 = line(pA,false,pA-(1,0));
line l2 = line(pE,false,pFi);

draw(l1^^l2);
draw(pA--pB,StickIntervalMarker(1,2,size=6,angle=-45,red));
draw(rotatedLabel("$6 \; cm$"),pB--pC,N);
draw(rotatedLabel("$4 \; cm$"),pC--pD,S,StickIntervalMarker(1,2,size=6,angle=-45,red));
draw(pD--pE,StickIntervalMarker(1,2,size=6,angle=-45,red));

markrightangle(pA-(1,0),pA,pB,blue);
markangle(Label("$35^\circ$"),pA,pB,pC,radius=12mm,blue,StickIntervalMarker(i=1,n=1,size=4,blue));
markangle(Label("$112^\circ$"),pB,pC,pD,radius=7mm,blue);
markangle(Label("$78^\circ$"),pC,pD,pE,radius=5mm,blue);
markangle(pD,pE,pFi,radius=12mm,blue,StickIntervalMarker(i=1,n=1,size=4,blue));

addMargins(30mm,0mm,40mm,0mm);
shipout(bbox(xmargin=1mm,invisible));

Utilisation de la routine perpendicular. Très pratique.

unitsize(0.85cm);
import geometry_dev;
usepackage("pifont");

point pO = (0,0);
point pA = (-3,0);
point pB = (5,0);
line lAB = line(pA,pB);
line lCE = perpendicular(pA,lAB);
point pF = (2,1.5);
line lCD = line(pO,pF);
line lBE = line(pB,pF);
point pC = intersectionpoint(lCD,lCE);
line lBD = parallel(pB,perpendicular(pF,lCD));
point pD = intersectionpoint(lBD,lCD);
point pE = intersectionpoint(lBE,lCE);

dot(Label("$O$",align=SE),pO);
dot(Label("$A$",align=NE),pA);
dot(Label("$B$",align=NE),pB);
dot(Label("$C$",align=SE),pC);
dot(Label("$D$",align=2N+0.5E),pD);
dot(Label("$E$",align=NE),pE);
dot(Label("$F$",align=2N),pF);

draw(lAB^^lCE^^lCD^^lBE^^lBD);

markrightangle(pB,pD,pF,blue);
markrightangle(pC,pA,pO,blue);

markangle(Label("\ding{172}"),pA,pE,pF,radius=5mm,blue);
markangle(Label("\ding{173}"),pO,pB,pF,radius=10mm,blue);
markangle(Label("\ding{174}"),pA,pO,pF,radius=3mm,blue);

addMargins(10mm,10mm,10mm,10mm);
shipout(bbox(xmargin=1mm,invisible));

Utilisation du module trembling_pi pour donner un effet “à main levée” à la figure. Le module base_pi n'est finalement pas utilisé mais aurait pu servir pour la commande rotatedLabel (qui permet d'aligner un label le long d'un objet). Ici, l'option rotate(dir(…)) a été préférée afin que le label apparaisse droit (en raison du trembling car rotatedLabel aligne sur la tangente).

unitsize(0.65cm);
import geometry_dev;
import trembling_pi;
import base_pi;

point pA = (0,0);
point pB = (6,0);
point pC = rotate(-90,pB)*pA;
point pD = pC+4*(rotate(-38)*unit(pB-pC));
point pE = pA+8*(rotate(126)*unit(pB-pA));

dot(Label("$A$",align=SW),pA);
dot(Label("$B$",align=SE),pB);
dot(Label("$C$",align=NE),pC);
dot(Label("$D$",align=SW),pD);
dot(Label("$E$",align=NW),pE);

draw(tremble(pA--pB,frequency=0.15),StickIntervalMarker(1,2,size=6,angle=-45,red,true));
draw(tremble(pB--pC,frequency=0.15),StickIntervalMarker(1,2,size=6,angle=-45,red,true));
draw(tremble(pC--pD,frequency=0.15));
draw(tremble(pA--pE,frequency=0.15));

label("$6 \; cm$",pA--pB,S);
label(rotate(dir(pE--pA))*"$8 \; cm$",pE--pA);
label(rotate(dir(pC--pD))*"$4 \; cm$",pC--pD);

markrightangle(pA,pB,pC,blue);
markangle(Label("$126^\circ$"),pE,pA,pB,radius=6mm,blue);
markangle(Label("$38^\circ$"),pB,pC,pD,radius=12mm,blue);

shipout(bbox(xmargin=1mm,invisible));

Cet exemple utilise la routine distance qui permet de réaliser des labels spéciaux qui sont souvent bien pratiques.

unitsize(1.75cm);
import geometry_dev;

point pA = (0,0);
point pB = (0,3);
point pC = (2,3);
point pD = (2,2);
point pE = (4,2);
point pF = (4,1);
point pG = (6,1);
point pH = (6,0);

filldraw(pA--pB--pC--pD--pE--pF--pG--pH--cycle,lightgrey);

markrightangle(pH,pA,pB,blue);
markrightangle(pA,pB,pC,blue);
markrightangle(pB,pC,pD,blue);
markrightangle(pD,pE,pF,blue);
markrightangle(pF,pG,pH,blue);
markrightangle(pG,pH,pA,blue);

distance(rotate(-90)*"$6$",pA,pB,-3mm);
distance("$y+3$",pB,pC,-3mm);
distance(rotate(+90)*"$1$",pG,pH,-3mm);
distance("$3y+6$",pA,pH,3mm);

draw(pC--(6,3),dotted);
draw(pE--(6,2),dotted);
draw(pE--(4,3),dotted);
draw(pG--(6,3),dotted);

distance("$y+1$",(4,3),(6,3),-3mm);
distance(rotate(-90)*"$3$",(6,2),(6,3),3mm);

shipout(bbox(xmargin=1mm,invisible));

Cet exemple utilise la routine intersectionpoints qui permet de récupérer la liste des points d'intersection entre deux chemins (ici deux cercles). Il utilise également les routines subpath et reltime (qui ne viennent pas du module geometry_dev d'ailleurs) mais qui permettent de récupérer un “morceau” de chemin.

unitsize(1cm);
import geometry_dev;
usepackage("mathrsfs");

real a = 6;
real b = 2;

point pB = (0,0);
point pU = (a,0);

path circle_1 = circle((a/2,0),a/2);
path circle_2 = circle(pU,b);

pair pT = intersectionpoints(circle_1,circle_2)[0];
pair pO = intersectionpoints(circle_1,circle_2)[1];

path scircle_1 = subpath(circle_1,reltime(circle_1,1/2),reltime(circle_1,1));
path scircle_2 = subpath(circle_2,reltime(circle_2,1/4+0.015),reltime(circle_2,3/4-0.015));

draw(Label("$\mathscr{C}$",Relative(.2)),scircle_1,gray);
draw(scircle_2,mediumgray);

dot(Label("$B$",align=W),pB); 
dot(Label("$U$",align=E),pU); 
dot(Label("$T$",align=N),pT); 
dot(Label("$O$",align=S),pO); 

draw(pB--pU--pO--pB^^pB--pT--pU);

draw(pU--pT,StickIntervalMarker(1,2,size=6,angle=-45,red,true));
draw(pU--pO,StickIntervalMarker(1,2,size=6,angle=-45,red,true)); 

shipout(bbox(xmargin=1mm,invisible));

Cet exemple utilise la routine compassmark qui permet de tracer des marques de constructions au compas.

unitsize(1cm);
import geometry_dev;

point pM = ( 2.5, 0);
point pR = (-2.5, 0);

point pS = intersectionpoints(circle(pR,3.5),circle(pM,3.5))[1];
point pT = intersectionpoints(circle(pR,7),circle(pM,7))[0];

draw(pR--pS--pM--pT--cycle);
draw(pR--pM);
draw(pS--pT,dashed);

draw(compassmark(pR, pS, position=0.5,angle=30), mediumgrey);
draw(compassmark(pM, pS, position=0.5,angle=30), mediumgrey);
draw(compassmark(pR, pT, position=0.5,angle=30), mediumgrey);
draw(compassmark(pM, pT, position=0.5,angle=30), mediumgrey);

dot(Label("$R$",align=W),pR);
dot(Label("$M$",align=E),pM);
dot(Label("$S$",align=N),pS);
dot(Label("$T$",align=S),pT);

shipout(bbox(xmargin=1mm,invisible));

Cet exemple utilise la routine distance avec des options (telles rotated=false) permettant de contrôler le placement du label.

unitsize(0.40cm);
import geometry_dev;

real a = 35;
currentcoordsys = cartesiansystem((0,0), i = (1,0), j = rotate(a,(0,0))*(1,0));

point pA = (0 ,0);
point pB = (12,0);
point pC = (12,5);
point pD = (0 ,5);

point pE = shift(0,5)*pA;
point pF = shift(0,5)*pB;
point pG = shift(0,5)*pC;
point pH = shift(0,5)*pD;

point pI = shift(0,7)*pA;
point pJ = shift(0,7)*pB;
point pK = shift(0,7)*pC;
point pL = shift(0,7)*pD;

fill(pE--pF--pG--pH--cycle^^pE--pF--pG--pC--pB--pA--cycle,lightgrey);
draw(pA--pB--pC);
draw(pC--pD--pA,dashed);
draw(pE--pF--pG--pH--cycle);
draw(pI--pJ--pK--pL--cycle);
dot(pI^^pJ^^pK^^pL);
draw(pA--pI^^pB--pJ^^pC--pK^^pH--pL);
draw(pD--pH,dashed);

distance("$14~\mathrm{m}$",pA,pB,3mm);
distance("$5~\mathrm{m}$",pB,pC,3mm);
distance("$x$",pA,pI,rotated=false,-3mm);
distance(Label("$10~\mathrm{cm}$",align=E),pG,pK,rotated=false,3mm);

shipout(bbox(xmargin=1mm,invisible));

Cet exemple illustre la façon dont on peut créer des labels à l'intérieur d'une ellipse, ainsi que l'utilisation de la commande midpoint.

unitsize(0.65cm);
import geometry_dev;
usepackage("mathrsfs");

int a = 7, b = 3, c = 4, d = 3;

point pA = (0,0);
point pB = (a+b,0);
point pC = (a+b,c+d);
point pD = (0,c+d);
point pE = (a,0);
point pF = (a+b,c);
point pG = (a,c+d);
point pH = (0,c);
point pO = (a,c);

draw(pA--pB--pC--pD--cycle);
draw(pE--pO^^pO--pG^^pH--pO^^pO--pF,dashed);

dot(pE^^pF^^pG^^pG^^pH^^pO);
dot(Label("$A$",align=SW),pA); 
dot(Label("$B$",align=SE),pB); 
dot(Label("$C$",align=NE),pC); 
dot(Label("$D$",align=NW),pD);

draw("$\mathscr{A}_1$",ellipse,midpoint(pA--pO),1bp);
draw("$\mathscr{A}_2$",ellipse,midpoint(pB--pO),1bp);
draw("$\mathscr{A}_3$",ellipse,midpoint(pC--pO),1bp);
draw("$\mathscr{A}_4$",ellipse,midpoint(pD--pO),1bp);

distance("$a$",pA,pE,7mm);
distance("$b$",pE,pB,7mm);
distance("$c$",pB,pF,rotated=false,7mm);
distance("$d$",pF,pC,rotated=false,7mm);

shipout(bbox(xmargin=1mm,invisible));

Cet exemple illustre la façon dont on peut utiliser la commande projection du module geometry_dev (qui permet de réaliser des projections orthogonales), ainsi que l'utilisation de la commande relpoint.

unitsize(0.75cm);
import geometry_dev;

point pO = (0,0);
point pG = (8,0);
point pH = (10,0);
point pI = (12,0);
point pS = (10,4);
point pB = relpoint(pO--pS,0.25);
point pA = projection(pO,pI)*pB;

fill(pG--pS--pI--cycle,lightgrey);
draw(pO--pG^^pS--pG^^pA--pB^^pS--pI);
draw(pO--pS^^pS--pH,dashed);
draw(pG--pI,StickIntervalMarker(2,2,size=6,angle=-45,red));

dot(Label("$O$",align=SW),pO);
dot(Label("$G$",align=SW),pG);
dot(Label("$H$",align=S),pH);
dot(Label("$I$",align=SE),pI);
dot(Label("$S$",align=N),pS);
dot(Label("$A$",align=S),pA);
dot(Label("$B$",align=N),pB);

shipout(bbox(xmargin=1mm,invisible));