Page 1 sur 1
Optimisation d'un code
Posté : ven. 1 févr. 2013, 18:50
par Fabrice
Bonsoir Gaetan,
Afin d'illustrer un exercice de devoir surveillé, j'ai dessiné une roue de loterie. Y-a-t-il des modules d'Asymptote que je ne connais qui auraient permis de faire un code plus court ?
Merci.
*** Pour masquer/découvrir le code Asymptote qui a permis de créer la figure, il faut cliquer dessus. ;-) ***
- CODE ASYMPTOTE de la figure ci-dessus :
Tout sélectionner
import geometry;
size(4cm,0);
pen[][] p={{lightgray},
{gray}};
point z1=(0,0);
circle C=circle(z1,1);
point z2=relpoint(C,11/16);
point z3=relpoint(C,13/16);
real n=8, a=360/n;
for (int i = 0; i < n; ++i)
filldraw(z1--arc(z1,1,i*a,(i+1)*a)--cycle,yellow);
filldraw(z1--arc(z1,1,45,90)--cycle^^z1--arc(z1,1,180,225)--cycle,orange);
point z4=angpoint(C,50);
point z5=angpoint(C,60);
point z6=rotate(90,z5)*z4;
point z7=rotate(-90,z4)*z5;
arc a1=arc(C,50,60);
latticeshade(buildcycle(a1,z5--z6,z6--z7,z7--z4),p);
draw(z4--z5--z6--z7--cycle);
point z8=scale(1.3,z1)*z2;
point z9=scale(1.3,z1)*z3;
arc a2=arc(C,247,292.5);
latticeshade(buildcycle(a2,z2--z8,z8--z9,z9--z1),p);
draw(z2--z8--z9--z3);
point z10=z8-0.1;
point z11=z9+0.1;
point z12 =shift(0,-0.1)*z10;
point z13 =shift(0,-0.1)*z11;
latticeshade(z8--z10--z12--z13--z11--z9--cycle,p);
draw(z8--z10--z12--z13--z11--z9--cycle);
point z14=0.9*dir(55);
point z15=midpoint(z6--z7);
draw(z15--z14,Arrow());
draw(C);
Re: Optimisation d'un code
Posté : ven. 1 févr. 2013, 20:06
par GM
Bonsoir,
Fabrice a écrit :Y-a-t-il des modules d'Asymptote que je ne connais qui auraient permis de faire un code plus court ?
Des modules... non, mais d'autres façons de faire assurément.
Contrairement à
l'autre demande du jour zariski, là par contre... je sais proposer quelque chose, sans chercher.
Donc si, c'est utile... je peux repartir d'une feuille blanche pour proposer ma solution.
Re: Optimisation d'un code
Posté : sam. 2 févr. 2013, 09:29
par Fabrice
Bonjour,
GM a écrit : mais d'autres façons de faire assurément
Oui, c'est sûr.
GM a écrit :Donc si, c'est utile... je peux repartir d'une feuille blanche pour proposer ma solution
Non, cela ira, de toutes façons, je sais que tu ferais mieux.
Merci.
Re: Optimisation d'un code
Posté : sam. 2 févr. 2013, 13:44
par GM
J'ai eu envie de m'amuser un peu.
*** Pour masquer/découvrir le code Asymptote qui a permis de créer la figure, il faut cliquer dessus. ;-) ***
- CODE ASYMPTOTE de la figure ci-dessus :
Tout sélectionner
import geometry;
size(5cm,0);
////////////////////////////////////////////
// PARAMETRES pour personnaliser la figure
point centre=(0,0); // centre de la roue
real r=2; // rayon de la roue
int n=9; // nombre de secteurs
pen[] col=array(n,white); // tableau des couleurs des n secteurs : blanc par défaut
pen couleurs[]={yellow,orange};
int seccol[][]={{0,1,3}, // les secteurs en couleurs[0],
{2,6,7}}; // les secteurs en couleurs[1],
// les autres en couleur par défaut.
real alpha=0; // angle correspondant au début du secteur 0
// Paramètres du support de roue et de sa base
real hsupp=0.1; // hauteur relative (fraction de r) du support
real lsupp=1.5; // largeur relative (fraction de r) du support
real hbase=0.05; // hauteur relative (fraction de r) de la base
real lbase=1.8; // largeur relative (fraction de r) de la base
// Paramètres du curseur de la roue
real tcur=.1; // taille relative du curseur
real acur=45; // position du curseur (angle en degrés)
///////////////////////////
circle C=circle(centre,r);
real a=360/n;
for (int j=0; j<seccol.length; ++j)
for (int k=0; k<seccol[j].length; ++k)
col[seccol[j][k]]=couleurs[j];
path support=centre--(-lsupp/2*r,-(1+hsupp)*r)--(lsupp/2*r,-(1+hsupp)*r)--cycle,
base=(-lbase/2*r,-(1+hsupp)*r)--(lbase/2*r,-(1+hsupp)*r)
--(lbase/2*r,-(1+hsupp+hbase)*r)--(-lbase/2*r,-(1+hsupp+hbase)*r)--cycle;
///////////////////////////////////////////////////////////
// CONSTRUCTIONS
picture pic1, pic2;
filldraw(pic1,(0,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,palegray);
filldraw(pic2,(r,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,darkred);
add(shift(centre)*rotate(acur)*(pic1));
axialshade(support^^base,gray,(0,-r-r*hsupp),lightgray,(0,-r+r*hsupp));
draw(support^^base);
for (int i = 0; i < n; ++i)
filldraw(centre--arc(C,alpha+i*a,alpha+(i+1)*a)--cycle,col[i]);
draw(C);
add(shift(centre)*rotate(acur)*(pic2));
*** Pour masquer/découvrir le code Asymptote qui a permis de créer la figure, il faut cliquer dessus. ;-) ***
- CODE ASYMPTOTE de la figure ci-dessus :
Tout sélectionner
import geometry;
size(5cm,0);
////////////////////////////////////////////
// PARAMETRES pour personnaliser la figure
point centre=(0,0); // centre de la roue
real r=2; // rayon de la roue
int n=12; // nombre de secteurs
pen[] col=array(n,white); // tableau des couleurs des n secteurs : blanc par défaut
pen couleurs[]={yellow,red,blue};
int seccol[][]={{1,3}, // les secteurs en couleurs[0]
{2,6,7}, // les secteurs en couleurs[1]
{0,8,11}}; // les secteurs en couleurs[2]
real alpha=0; // angle correspondant au début du secteur 0
// Paramètres du support de roue et de sa base
real hsupp=0.1; // hauteur relative (fraction de r) du support
real lsupp=1.5; // largeur relative (fraction de r) du support
real hbase=0.05; // hauteur relative (fraction de r) de la base
real lbase=1.8; // largeur relative (fraction de r) de la base
// Paramètres du curseur de la roue
real tcur=.15; // taille relative du curseur
real acur=45; // position du curseur (angle en degrés)
///////////////////////////
circle C=circle(centre,r);
real a=360/n;
for (int j=0; j<seccol.length; ++j)
for (int k=0; k<seccol[j].length; ++k)
col[seccol[j][k]]=couleurs[j];
path support=centre--(-lsupp/2*r,-(1+hsupp)*r)--(lsupp/2*r,-(1+hsupp)*r)--cycle,
base=(-lbase/2*r,-(1+hsupp)*r)--(lbase/2*r,-(1+hsupp)*r)
--(lbase/2*r,-(1+hsupp+hbase)*r)--(-lbase/2*r,-(1+hsupp+hbase)*r)--cycle;
///////////////////////////////////////////////////////////
// CONSTRUCTIONS
picture pic1, pic2;
filldraw(pic1,(0,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,palegray);
filldraw(pic2,(r,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,darkred);
add(shift(centre)*rotate(acur)*(pic1));
axialshade(support^^base,gray,(0,-r-r*hsupp),lightgray,(0,-r+r*hsupp));
draw(support^^base);
for (int i = 0; i < n; ++i)
filldraw(centre--arc(C,alpha+i*a,alpha+(i+1)*a)--cycle,col[i]);
draw(C);
add(shift(centre)*rotate(acur)*(pic2));
L'idée a été... de pouvoir proposer quelque chose d'un peu différent... avec un peu plus de facilités pour pouvoir faire des roues différentes, sans modifier le code.
*** Pour masquer/découvrir le code Asymptote qui a permis de créer la figure, il faut cliquer dessus. ;-) ***
- CODE ASYMPTOTE de la figure ci-dessus :
Tout sélectionner
import geometry;
size(5cm,0);
////////////////////////////////////////////
// PARAMETRES pour personnaliser la figure
point centre=(0,0); // centre de la roue
real r=2; // rayon de la roue
int n=8; // nombre de secteurs
pen[] col=array(n,paleblue); // tableau des couleurs des n secteurs : bleu pâle par défaut
pen couleurs[]={yellow,red};
int seccol[][]={{1,3}, // les secteurs en couleurs[0]
{2,6,7}}; // les secteurs en couleurs[1]
real alpha=30; // angle correspondant au début du secteur 0
// Paramètres du support de roue et de sa base
real hsupp=0.1; // hauteur relative (fraction de r) du support
real lsupp=1.8; // largeur relative (fraction de r) du support
real hbase=0.05; // hauteur relative (fraction de r) de la base
real lbase=2; // largeur relative (fraction de r) de la base
// Paramètres du curseur de la roue
real tcur=.15; // taille relative du curseur
real acur=150; // position du curseur (angle en degrés)
///////////////////////////
circle C=circle(centre,r);
real a=360/n;
for (int j=0; j<seccol.length; ++j)
for (int k=0; k<seccol[j].length; ++k)
col[seccol[j][k]]=couleurs[j];
path support=centre--(-lsupp/2*r,-(1+hsupp)*r)--(lsupp/2*r,-(1+hsupp)*r)--cycle,
base=(-lbase/2*r,-(1+hsupp)*r)--(lbase/2*r,-(1+hsupp)*r)
--(lbase/2*r,-(1+hsupp+hbase)*r)--(-lbase/2*r,-(1+hsupp+hbase)*r)--cycle;
///////////////////////////////////////////////////////////
// CONSTRUCTIONS
picture pic1, pic2;
filldraw(pic1,(0,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,palegray);
filldraw(pic2,(r,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,darkred);
add(shift(centre)*rotate(acur)*(pic1));
axialshade(support^^base,gray,(0,-r-r*hsupp),lightgray,(0,-r+r*hsupp));
draw(support^^base);
for (int i = 0; i < n; ++i)
filldraw(centre--arc(C,alpha+i*a,alpha+(i+1)*a)--cycle,col[i]);
draw(C);
add(shift(centre)*rotate(acur)*(pic2));
NB : j'ai joué sur l'effet de superposition pour pouvoir me limiter à des coloriages de formes simples avec certaines parties masquées par d'autres..
Re: Optimisation d'un code
Posté : sam. 2 févr. 2013, 13:56
par GM
Précision : j'ai fait le choix qu'en changeant le centre, on puisse avoir un support un peu original mais il n'y a pas grand chose à changer pour qu'il reste de forme initiale quand on change le centre.
*** Pour masquer/découvrir le code Asymptote qui a permis de créer la figure, il faut cliquer dessus. ;-) ***
- CODE ASYMPTOTE de la figure ci-dessus :
Tout sélectionner
import geometry;
size(5cm,0);
////////////////////////////////////////////
// PARAMETRES pour personnaliser la figure
point centre=(1,0); // centre de la roue
real r=2; // rayon de la roue
int n=8; // nombre de secteurs
pen[] col=array(n,palegreen); // tableau des couleurs des n secteurs : vert pâle par défaut
pen couleurs[]={.9red,orange};
int seccol[][]={{1,3}, // les secteurs en couleurs[0]
{2,6,7}}; // les secteurs en couleurs[1]
real alpha=-10; // angle correspondant au début du secteur 0
// Paramètres du support de roue et de sa base
real hsupp=0.1; // hauteur relative (fraction de r) du support
real lsupp=1.8; // largeur relative (fraction de r) du support
real hbase=0.05; // hauteur relative (fraction de r) de la base
real lbase=2; // largeur relative (fraction de r) de la base
// Paramètres du curseur de la roue
real tcur=.15; // taille relative du curseur
real acur=45; // position du curseur (angle en degrés)
///////////////////////////
circle C=circle(centre,r);
real a=360/n;
for (int j=0; j<seccol.length; ++j)
for (int k=0; k<seccol[j].length; ++k)
col[seccol[j][k]]=couleurs[j];
path support=centre--(-lsupp/2*r,-(1+hsupp)*r)--(lsupp/2*r,-(1+hsupp)*r)--cycle,
base=(-lbase/2*r,-(1+hsupp)*r)--(lbase/2*r,-(1+hsupp)*r)
--(lbase/2*r,-(1+hsupp+hbase)*r)--(-lbase/2*r,-(1+hsupp+hbase)*r)--cycle;
///////////////////////////////////////////////////////////
// CONSTRUCTIONS
picture pic1, pic2;
filldraw(pic1,(0,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,palegray);
filldraw(pic2,(r,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,darkred);
add(shift(centre)*rotate(acur)*(pic1));
axialshade(support^^base,gray,(0,-r-r*hsupp),lightgray,(0,-r+r*hsupp));
draw(support^^base);
for (int i = 0; i < n; ++i)
filldraw(centre--arc(C,alpha+i*a,alpha+(i+1)*a)--cycle,col[i]);
draw(C);
add(shift(centre)*rotate(acur)*(pic2));