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.

Figure asymptote d80966524aa4d1d69792d9786a8c5324
*** 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
  1. import geometry;
  2. size(4cm,0);
  3. pen[][] p={{lightgray},
  4. {gray}};
  5. point z1=(0,0);
  6. circle C=circle(z1,1);
  7. point z2=relpoint(C,11/16);
  8. point z3=relpoint(C,13/16);
  9. real n=8, a=360/n;
  10. for (int i = 0; i < n; ++i)
  11. filldraw(z1--arc(z1,1,i*a,(i+1)*a)--cycle,yellow);
  12. filldraw(z1--arc(z1,1,45,90)--cycle^^z1--arc(z1,1,180,225)--cycle,orange);
  13. point z4=angpoint(C,50);
  14. point z5=angpoint(C,60);
  15. point z6=rotate(90,z5)*z4;
  16. point z7=rotate(-90,z4)*z5;
  17. arc a1=arc(C,50,60);
  18. latticeshade(buildcycle(a1,z5--z6,z6--z7,z7--z4),p);
  19. draw(z4--z5--z6--z7--cycle);
  20. point z8=scale(1.3,z1)*z2;
  21. point z9=scale(1.3,z1)*z3;
  22. arc a2=arc(C,247,292.5);
  23. latticeshade(buildcycle(a2,z2--z8,z8--z9,z9--z1),p);
  24. draw(z2--z8--z9--z3);
  25. point z10=z8-0.1;
  26. point z11=z9+0.1;
  27. point z12 =shift(0,-0.1)*z10;
  28. point z13 =shift(0,-0.1)*z11;
  29. latticeshade(z8--z10--z12--z13--z11--z9--cycle,p);
  30. draw(z8--z10--z12--z13--z11--z9--cycle);
  31. point z14=0.9*dir(55);
  32. point z15=midpoint(z6--z7);
  33. draw(z15--z14,Arrow());
  34. 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.

Figure asymptote 1da4b7896b56e0b584d5df4a9a4ef550
*** 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
  1. import geometry;
  2. size(5cm,0);
  3. ////////////////////////////////////////////
  4. // PARAMETRES pour personnaliser la figure
  5. point centre=(0,0); // centre de la roue
  6. real r=2; // rayon de la roue
  7. int n=9; // nombre de secteurs
  8. pen[] col=array(n,white); // tableau des couleurs des n secteurs : blanc par défaut
  9. pen couleurs[]={yellow,orange};
  10. int seccol[][]={{0,1,3}, // les secteurs en couleurs[0],
  11. {2,6,7}}; // les secteurs en couleurs[1],
  12. // les autres en couleur par défaut.
  13. real alpha=0; // angle correspondant au début du secteur 0
  14. // Paramètres du support de roue et de sa base
  15. real hsupp=0.1; // hauteur relative (fraction de r) du support
  16. real lsupp=1.5; // largeur relative (fraction de r) du support
  17. real hbase=0.05; // hauteur relative (fraction de r) de la base
  18. real lbase=1.8; // largeur relative (fraction de r) de la base
  19. // Paramètres du curseur de la roue
  20. real tcur=.1; // taille relative du curseur
  21. real acur=45; // position du curseur (angle en degrés)
  22. ///////////////////////////
  23. circle C=circle(centre,r);
  24. real a=360/n;
  25. for (int j=0; j<seccol.length; ++j)
  26. for (int k=0; k<seccol[j].length; ++k)
  27. col[seccol[j][k]]=couleurs[j];
  28. path support=centre--(-lsupp/2*r,-(1+hsupp)*r)--(lsupp/2*r,-(1+hsupp)*r)--cycle,
  29. base=(-lbase/2*r,-(1+hsupp)*r)--(lbase/2*r,-(1+hsupp)*r)
  30. --(lbase/2*r,-(1+hsupp+hbase)*r)--(-lbase/2*r,-(1+hsupp+hbase)*r)--cycle;
  31. ///////////////////////////////////////////////////////////
  32. // CONSTRUCTIONS
  33. picture pic1, pic2;
  34. filldraw(pic1,(0,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,palegray);
  35. filldraw(pic2,(r,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,darkred);
  36. add(shift(centre)*rotate(acur)*(pic1));
  37. axialshade(support^^base,gray,(0,-r-r*hsupp),lightgray,(0,-r+r*hsupp));
  38. draw(support^^base);
  39. for (int i = 0; i < n; ++i)
  40. filldraw(centre--arc(C,alpha+i*a,alpha+(i+1)*a)--cycle,col[i]);
  41. draw(C);
  42. add(shift(centre)*rotate(acur)*(pic2));


Figure asymptote 96896566ee2f1f91b63550ef9534797b
*** 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
  1. import geometry;
  2. size(5cm,0);
  3. ////////////////////////////////////////////
  4. // PARAMETRES pour personnaliser la figure
  5. point centre=(0,0); // centre de la roue
  6. real r=2; // rayon de la roue
  7. int n=12; // nombre de secteurs
  8. pen[] col=array(n,white); // tableau des couleurs des n secteurs : blanc par défaut
  9. pen couleurs[]={yellow,red,blue};
  10. int seccol[][]={{1,3}, // les secteurs en couleurs[0]
  11. {2,6,7}, // les secteurs en couleurs[1]
  12. {0,8,11}}; // les secteurs en couleurs[2]
  13. real alpha=0; // angle correspondant au début du secteur 0
  14. // Paramètres du support de roue et de sa base
  15. real hsupp=0.1; // hauteur relative (fraction de r) du support
  16. real lsupp=1.5; // largeur relative (fraction de r) du support
  17. real hbase=0.05; // hauteur relative (fraction de r) de la base
  18. real lbase=1.8; // largeur relative (fraction de r) de la base
  19. // Paramètres du curseur de la roue
  20. real tcur=.15; // taille relative du curseur
  21. real acur=45; // position du curseur (angle en degrés)
  22. ///////////////////////////
  23. circle C=circle(centre,r);
  24. real a=360/n;
  25. for (int j=0; j<seccol.length; ++j)
  26. for (int k=0; k<seccol[j].length; ++k)
  27. col[seccol[j][k]]=couleurs[j];
  28. path support=centre--(-lsupp/2*r,-(1+hsupp)*r)--(lsupp/2*r,-(1+hsupp)*r)--cycle,
  29. base=(-lbase/2*r,-(1+hsupp)*r)--(lbase/2*r,-(1+hsupp)*r)
  30. --(lbase/2*r,-(1+hsupp+hbase)*r)--(-lbase/2*r,-(1+hsupp+hbase)*r)--cycle;
  31. ///////////////////////////////////////////////////////////
  32. // CONSTRUCTIONS
  33. picture pic1, pic2;
  34. filldraw(pic1,(0,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,palegray);
  35. filldraw(pic2,(r,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,darkred);
  36. add(shift(centre)*rotate(acur)*(pic1));
  37. axialshade(support^^base,gray,(0,-r-r*hsupp),lightgray,(0,-r+r*hsupp));
  38. draw(support^^base);
  39. for (int i = 0; i < n; ++i)
  40. filldraw(centre--arc(C,alpha+i*a,alpha+(i+1)*a)--cycle,col[i]);
  41. draw(C);
  42. 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.

Figure asymptote c0cb484af462d41ec07f1ac486601647
*** 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
  1. import geometry;
  2. size(5cm,0);
  3. ////////////////////////////////////////////
  4. // PARAMETRES pour personnaliser la figure
  5. point centre=(0,0); // centre de la roue
  6. real r=2; // rayon de la roue
  7. int n=8; // nombre de secteurs
  8. pen[] col=array(n,paleblue); // tableau des couleurs des n secteurs : bleu pâle par défaut
  9. pen couleurs[]={yellow,red};
  10. int seccol[][]={{1,3}, // les secteurs en couleurs[0]
  11. {2,6,7}}; // les secteurs en couleurs[1]
  12. real alpha=30; // angle correspondant au début du secteur 0
  13. // Paramètres du support de roue et de sa base
  14. real hsupp=0.1; // hauteur relative (fraction de r) du support
  15. real lsupp=1.8; // largeur relative (fraction de r) du support
  16. real hbase=0.05; // hauteur relative (fraction de r) de la base
  17. real lbase=2; // largeur relative (fraction de r) de la base
  18. // Paramètres du curseur de la roue
  19. real tcur=.15; // taille relative du curseur
  20. real acur=150; // position du curseur (angle en degrés)
  21. ///////////////////////////
  22. circle C=circle(centre,r);
  23. real a=360/n;
  24. for (int j=0; j<seccol.length; ++j)
  25. for (int k=0; k<seccol[j].length; ++k)
  26. col[seccol[j][k]]=couleurs[j];
  27. path support=centre--(-lsupp/2*r,-(1+hsupp)*r)--(lsupp/2*r,-(1+hsupp)*r)--cycle,
  28. base=(-lbase/2*r,-(1+hsupp)*r)--(lbase/2*r,-(1+hsupp)*r)
  29. --(lbase/2*r,-(1+hsupp+hbase)*r)--(-lbase/2*r,-(1+hsupp+hbase)*r)--cycle;
  30. ///////////////////////////////////////////////////////////
  31. // CONSTRUCTIONS
  32. picture pic1, pic2;
  33. filldraw(pic1,(0,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,palegray);
  34. filldraw(pic2,(r,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,darkred);
  35. add(shift(centre)*rotate(acur)*(pic1));
  36. axialshade(support^^base,gray,(0,-r-r*hsupp),lightgray,(0,-r+r*hsupp));
  37. draw(support^^base);
  38. for (int i = 0; i < n; ++i)
  39. filldraw(centre--arc(C,alpha+i*a,alpha+(i+1)*a)--cycle,col[i]);
  40. draw(C);
  41. 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.

Figure asymptote 53fe874829fcf281af3845804955bb51
*** 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
  1. import geometry;
  2. size(5cm,0);
  3. ////////////////////////////////////////////
  4. // PARAMETRES pour personnaliser la figure
  5. point centre=(1,0); // centre de la roue
  6. real r=2; // rayon de la roue
  7. int n=8; // nombre de secteurs
  8. pen[] col=array(n,palegreen); // tableau des couleurs des n secteurs : vert pâle par défaut
  9. pen couleurs[]={.9red,orange};
  10. int seccol[][]={{1,3}, // les secteurs en couleurs[0]
  11. {2,6,7}}; // les secteurs en couleurs[1]
  12. real alpha=-10; // angle correspondant au début du secteur 0
  13. // Paramètres du support de roue et de sa base
  14. real hsupp=0.1; // hauteur relative (fraction de r) du support
  15. real lsupp=1.8; // largeur relative (fraction de r) du support
  16. real hbase=0.05; // hauteur relative (fraction de r) de la base
  17. real lbase=2; // largeur relative (fraction de r) de la base
  18. // Paramètres du curseur de la roue
  19. real tcur=.15; // taille relative du curseur
  20. real acur=45; // position du curseur (angle en degrés)
  21. ///////////////////////////
  22. circle C=circle(centre,r);
  23. real a=360/n;
  24. for (int j=0; j<seccol.length; ++j)
  25. for (int k=0; k<seccol[j].length; ++k)
  26. col[seccol[j][k]]=couleurs[j];
  27. path support=centre--(-lsupp/2*r,-(1+hsupp)*r)--(lsupp/2*r,-(1+hsupp)*r)--cycle,
  28. base=(-lbase/2*r,-(1+hsupp)*r)--(lbase/2*r,-(1+hsupp)*r)
  29. --(lbase/2*r,-(1+hsupp+hbase)*r)--(-lbase/2*r,-(1+hsupp+hbase)*r)--cycle;
  30. ///////////////////////////////////////////////////////////
  31. // CONSTRUCTIONS
  32. picture pic1, pic2;
  33. filldraw(pic1,(0,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,palegray);
  34. filldraw(pic2,(r,0)--r+tcur*r*dir(-30)--r+tcur*r*dir(30)--cycle,darkred);
  35. add(shift(centre)*rotate(acur)*(pic1));
  36. axialshade(support^^base,gray,(0,-r-r*hsupp),lightgray,(0,-r+r*hsupp));
  37. draw(support^^base);
  38. for (int i = 0; i < n; ++i)
  39. filldraw(centre--arc(C,alpha+i*a,alpha+(i+1)*a)--cycle,col[i]);
  40. draw(C);
  41. add(shift(centre)*rotate(acur)*(pic2));