ASY-Forum

dédié à Asymptote, puissant langage de graphisme vectoriel.
http://asy.marris.fr/forum/

[buildcycle] Comment arranger ça ?

http://asy.marris.fr/forum/viewtopic.php?f=15&t=322

Page 1 sur 2

[buildcycle] Comment arranger ça ?

Posté : jeu. 29 août 2013, 22:20
par maurice
Bonjour, j'ai besoin de quelques précisions pour l'utilisation de buildcycle.
Pour le trefle, pas de problème, même si je ne sais pas si l'imbrication des buildcycle est recommendée...

Figure asymptote e46410262991c3d309abdb53f4e67815
*** 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. size(200);
  2. path trefle(pair a, pair b)
  3. {
  4.   real angle=60;
  5.   pair centre=((a.x+b.x)/2, (4*a.y+3*b.y)/7),
  6.     p1=((3*a.x+b.x)/4, (3*a.y+b.y)/4),
  7.     p2=(a.x, centre.y),
  8.     p3=(p1.x, p2.y+centre.y-p1.y);
  9.   path feuille1=centre{dir(180+angle)}..{left}p1{left}..{up}p2{up}..{right}p3{right}..{dir(-angle)}cycle;
  10.   path feuille2=rotate(-90, centre)*feuille1;
  11.   path feuille3=rotate(180, centre)*feuille1;
  12.   path pied=((9*centre.x+b.x)/10, centre.y){down}..{right}((a.x+3*b.x)/4, a.y)--((3*a.x+b.x)/4, a.y){right}..{up}((9*centre.x+a.x)/10, centre.y);
  13.   path g=buildcycle(buildcycle(buildcycle(feuille1, feuille2), feuille3), pied);
  14.   // path[] g={feuille1, feuille2, feuille3, pied};
  15.   return g;
  16. }
  17.  
  18. path p=trefle((-1,-1), (1,1));
  19. draw(p);


Mais pour le trefle à 4 feuilles, il y a un petit soucis :

Figure asymptote e0d76658c499bd257f2792cbac5d53f5
*** 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. size(200);
  2. path trefle4(pair a, pair b)
  3. {
  4.   real angle=60;
  5.   pair centre=((a.x+b.x)/2, (4*a.y+3*b.y)/7),
  6.     p1=((3*a.x+b.x)/4, (3*a.y+b.y)/4),
  7.     p2=(a.x, centre.y),
  8.     p3=(p1.x, p2.y+centre.y-p1.y);
  9.   path feuille1=centre{dir(180+angle)}..{left}p1{left}..{up}p2{up}..{right}p3{right}..{dir(-angle)}cycle;
  10.   path feuille2=rotate(-90, centre)*feuille1;
  11.   path feuille3=rotate(180, centre)*feuille1;
  12.   path feuille4=rotate(90, centre)*feuille1;
  13.   path g=buildcycle(buildcycle(buildcycle(feuille1, feuille2), feuille3), feuille4);
  14.   return g;
  15. }
  16.  
  17. path p=trefle4((-1,-1), (1,1));
  18. draw(p);


Merci d'avance

Bruno

Re: [buildcycle] Comment arranger ça ?

Posté : ven. 30 août 2013, 08:11
par GM
maurice a écrit :Bonjour, j'ai besoin de quelques précisions pour l'utilisation de buildcycle.
Pour le trèfle, pas de problème, même si je ne sais pas si l'imbrication des buildcycle est recommandée...

Bonjour,

en fait... c'est l'utilisation de buildcycle dont on peut se demander si elle est recommandée, étant donné qu'elle ne peut s'employer sans tâtonner, tellement le résultat est imprévisible. Pour ceux qui passent par là... sans connaitre cette fonction, je rappelle une série d'exemples (http://www.marris.org/asymptote/Contours_Domaines/index.html#fig_bc01_300309_buildcycle) qui montre à quel point, cela peut-être subtile... au point d'ailleurs que la doc d'Asymptote n'en parle pas, je crois, car buildcycle se veut une commande interne dont JCBowman n'a pas fait la promotion dans la galerie officielle.

Pour l'imbrication... pourquoi pas.

Pour le trèfle, je n'y ai pas encore réfléchi.

Re: [buildcycle] Comment arranger ça ?

Posté : ven. 30 août 2013, 08:38
par GM
GM a écrit :Pour le trèfle, je n'y ai pas encore réfléchi.


Je viens de le faire... en numérotant les noeuds : seule façon de voir ce que fait buildcycle.

Figure asymptote 46da56bc9b94cb8875cd7eb8158f19ad
*** 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. size(200);
  2. path trefle4(pair a, pair b)
  3. {
  4. real angle=60;
  5. pair centre=((a.x+b.x)/2, (4*a.y+3*b.y)/7),
  6. p1=((3*a.x+b.x)/4, (3*a.y+b.y)/4),
  7. p2=(a.x, centre.y),
  8. p3=(p1.x, p2.y+centre.y-p1.y);
  9. path feuille1=centre{dir(180+angle)}..{left}p1{left}..{up}p2{up}..{right}p3{right}..{dir(-angle)}cycle;
  10. path feuille2=rotate(-90, centre)*feuille1;
  11. path feuille3=rotate(180, centre)*feuille1;
  12. path feuille4=rotate(90, centre)*feuille1;
  13. path g=buildcycle(buildcycle(feuille1, feuille2), feuille3); 
  14.  
  15. draw(g,3bp+red);
  16. for(int k=0; k<size(g); ++k) dot(string(k),point(g,k),4bp+red,align=E);
  17. draw(feuille4,3bp+blue);
  18. for(int k=0; k<size(feuille4); ++k) dot(string(k),point(feuille4,k),4bp+blue,align=W);
  19.  
  20. g=buildcycle(g,feuille4);
  21. return g;
  22. }
  23. path p=trefle4((-1,-1), (1,1));
  24. draw(p,.8bp+green);
  25. for(int k=0; k<size(p); ++k) dot(string(k),point(p,k),2bp+green,align=S);


Et cela permet de comprendre que buildcycle cherche les points communs aux paths mais ne tient compte que de deux d'entre eux.
Or ici, les paths buildcycle(buildcycle(feuille1, feuille2), feuille3) et g ont trois points communs et l'un est ignoré dans la construction résultante.

Re: [buildcycle] Comment arranger ça ?

Posté : ven. 30 août 2013, 09:00
par GM
Je vais devoir ajouter un exemple dans la galerie (où les paths ont davantage que deux points d'intersection) pour convaincre que buildcycle n'est pas d'usage simple et n'a pas été conçu pour l'être puisqu'elle n'est pas dans la doc Asymptote. Et donc, cela peut donner des résultats surprenant comme ceux-ci :

Figure asymptote 17a240a02ad6f0e5c717f2a0a3ee3ef1
*** 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. size(300);
  2. path p1=(0,0)--(1,1)--(-.5,1.5)--(-0.5,-1.5)--cycle;
  3. path p2=unitcircle;
  4. path p=buildcycle(p1,p2);
  5. fill(p,gray);
  6. draw(p1,3bp+.7blue); draw(p2,3bp+.7red); 
  7. draw(p,1bp+yellow);
  8. defaultpen(fontsize(16pt));
  9. for(int i=0; i<length(p1); ++i) 
  10.     dot(string(i),point(p1,i),SW,5bp+.7blue);
  11. for(int i=0; i<length(p2); ++i) 
  12.     dot(string(i),point(p2,i),SW,5bp+.7red);
  13. for(int i=0; i<length(p); ++i) 
  14.     dot(string(i),point(p,i),E,3bp+black);


Figure asymptote 62745ecf4172e9559d9fd1f2542efa18
*** 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. size(300);
  2. path p1=(0,0)--(1,1)--(-.5,1.5)--(-0.5,-1.5)--cycle;
  3. path p2=unitcircle;
  4. path p=buildcycle(p2,p1);
  5. fill(p,gray);
  6. draw(p1,3bp+.7blue); draw(p2,3bp+.7red); 
  7. draw(p,1bp+yellow);
  8. defaultpen(fontsize(16pt));
  9. for(int i=0; i<length(p1); ++i) 
  10.     dot(string(i),point(p1,i),SW,5bp+.7blue);
  11. for(int i=0; i<length(p2); ++i) 
  12.     dot(string(i),point(p2,i),SW,5bp+.7red);
  13. for(int i=0; i<length(p); ++i) 
  14.     dot(string(i),point(p,i),E,3bp+black);


Figure asymptote 4aa39004b597186bb98ed630091ffc8d
*** 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. size(300);
  2. path p1=(0,0)--(1,1)--(-.5,1.5)--(-0.5,-1.5)--cycle;
  3. path p2=unitcircle;
  4. path p3=shift(-0.1,1.1)*unitcircle;
  5. path p=buildcycle(p1,p2,p3);
  6. fill(p,gray);
  7. draw(p1,3bp+.7blue); draw(p2,3bp+.7red); draw(p3,3bp+.7green);  
  8. draw(p,1bp+yellow);
  9. defaultpen(fontsize(16pt));
  10. for(int i=0; i<length(p1); ++i) 
  11.     dot(string(i),point(p1,i),SW,5bp+.7blue);
  12. for(int i=0; i<length(p2); ++i) 
  13.     dot(string(i),point(p2,i),SW,5bp+.7red);
  14. for(int i=0; i<length(p3); ++i) 
  15.     dot(string(i),point(p3,i),E,5bp+.5green);
  16. for(int i=0; i<length(p); ++i) 
  17.     dot(string(i),point(p,i),N,4bp+black);


Figure asymptote 64866a005c665f8fe0afd82a2fb8271e
*** 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. size(300);
  2. path p1=(0,0)--(1,1)--(-.5,1.5)--(-0.5,-1.5)--cycle;
  3. path p2=unitcircle;
  4. path p3=shift(-0.1,1.1)*unitcircle;
  5. path p=buildcycle(p3,p2,p1);
  6. fill(p,gray);
  7. draw(p1,3bp+.7blue); draw(p2,3bp+.7red); draw(p3,3bp+.7green);  
  8. draw(p,1bp+yellow);
  9. defaultpen(fontsize(16pt));
  10. for(int i=0; i<length(p1); ++i) 
  11.     dot(string(i),point(p1,i),SW,5bp+.7blue);
  12. for(int i=0; i<length(p2); ++i) 
  13.     dot(string(i),point(p2,i),SW,5bp+.7red);
  14. for(int i=0; i<length(p3); ++i) 
  15.     dot(string(i),point(p3,i),E,5bp+.5green);
  16. for(int i=0; i<length(p); ++i) 
  17.     dot(string(i),point(p,i),N,4bp+black);


Ces exemples doivent permettre de réaliser que faire des fonctions impliquant buildcycle pourrait donner des résultats inattendus... suivant les valeurs données aux paramètres.

Re: [buildcycle] Comment arranger ça ?

Posté : ven. 30 août 2013, 21:14
par maurice
Merci pour les explications, je vais étudier tout ça et essayer de trouver une solution sans de buildcycle.

Bruno

Re: [buildcycle] Comment arranger ça ?

Posté : sam. 31 août 2013, 22:07
par maurice
Bonjour, j'ai utilisé intersections(path, path); et subpath(path, rfeal, real);

Figure asymptote b580988e72a9ecfbf65d1ba08de8ed8c
*** 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. size(200);
  2.  
  3. path[] g5(pair a, pair b)
  4. {
  5.   real angle=60;
  6.   pair centre=((a.x+b.x)/2, (4*a.y+3*b.y)/7),
  7.     p1=((3*a.x+b.x)/4, (3*a.y+b.y)/4),
  8.     p2=(a.x, centre.y),
  9.     p3=(p1.x, p2.y+centre.y-p1.y);
  10.   path f1=centre{dir(180+angle)}..{left}p1{left}..{up}p2{up}..{right}p3{right}..{dir(-angle)}cycle;
  11.   path f2=rotate(-90, centre)*(centre{dir(180+angle)}..{left}p1);
  12.   path f3=rotate(90, centre)*(p3{right}..{dir(-angle)}centre);
  13.   real[][] t2=intersections(f1, f2);
  14.   real[][] t3=intersections(f1, f3);
  15.   path feuille=subpath(f1, t3[1][0], t2[1][0]);
  16.   // draw(feuille, 4bp+red);
  17.   // return buildcycle(feuille, rotate(90,centre)*feuille, rotate(180,centre)*feuille, rotate(270, centre)*feuille);
  18.   return feuille^^rotate(90,centre)*feuille^^rotate(180,centre)*feuille^^rotate(270, centre)*feuille;
  19. }
  20.  
  21. path[] p=g5((-1,-1), (1,1));
  22. draw(p, 2bp+green);


Avec le buildcycle et des path à la place de path[], ça marche aussi ! Par contre, dans le cas ci-dessus je ne peux pas remplir le text. Pour cela, il faut utiliser buildcycle.
Y'a-t-il une fonction concaténation pour les path ?

Bruno

Re: [buildcycle] Comment arranger ça ?

Posté : sam. 31 août 2013, 23:09
par GM
maurice a écrit :Y'a-t-il une fonction concaténation pour les path ?

Oui... et tu vas te dire : pourquoi je n'y ai pas pensé ? :-))

Je n'ai modifié que la fin pour répondre à ta question... sans lire en détail le début, mais je crois que tu as fait les choses de façon bien compliquée, il me semble.

Figure asymptote 9ea6f1d23806b80c08f06806c88a24e1
*** 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. size(200);
  2.  
  3. path[] g5(pair a, pair b)
  4. {
  5.     real angle=60;
  6.     pair centre=((a.x+b.x)/2, (4*a.y+3*b.y)/7),
  7.          p1=((3*a.x+b.x)/4, (3*a.y+b.y)/4),
  8.          p2=(a.x, centre.y),
  9.          p3=(p1.x, p2.y+centre.y-p1.y);
  10.     path f1=centre{dir(180+angle)}..{left}p1{left}..{up}p2{up}..{right}p3{right}..{dir(-angle)}cycle;
  11.     path f2=rotate(-90, centre)*(centre{dir(180+angle)}..{left}p1);
  12.     path f3=rotate(90, centre)*(p3{right}..{dir(-angle)}centre);
  13.     real[][] t2=intersections(f1, f2);
  14.     real[][] t3=intersections(f1, f3);
  15.     path feuille=subpath(f1, t3[1][0], t2[1][0]);
  16.     return feuille--(rotate(-90,centre)*feuille)--(rotate(-180,centre)*feuille)--(rotate(-270,centre)*feuille)--cycle;
  17. }
  18.  
  19. path[] p=g5((-1,-1), (1,1));
  20. filldraw(p, green, 2bp+.5green);

Re: [buildcycle] Comment arranger ça ?

Posté : sam. 31 août 2013, 23:14
par GM
GM a écrit :... mais je crois que tu as fait les choses de façon bien compliquée, il me semble.

Par curiosité, je viens de placer les points (-1,-1) et (1,1) et le placement du trèfle par rapport à ces points me fait m'interroger : pourquoi si compliqué ? Où est la motivation dans ce choix de centre ?

Re: [buildcycle] Comment arranger ça ?

Posté : sam. 31 août 2013, 23:51
par maurice
Bonsoir,

GM a écrit :
maurice a écrit :Y'a-t-il une fonction concaténation pour les path ?

Oui... et tu vas te dire : pourquoi je n'y ai pas pensé ? :-))


J'y avais effectivement pensé mais avec des mesures d'angles positives, du coup, forcément ...

GM a écrit :
GM a écrit :... mais je crois que tu as fait les choses de façon bien compliquée, il me semble.

Par curiosité, je viens de placer les points (-1,-1) et (1,1) et le placement du trèfle par rapport à ces points me fait m'interroger : pourquoi si compliqué ? Où est la motivation dans ce choix de centre ?


C'est juste que je suis parti du trèfle à trois feuilles (post1) et je voulais que le pied soit un peu plus long ! C'est tout. Ce n'est effectivement pas justifié pour ici.

Quant au reste, je n'est pas trouvé plus simple pour faire une feuille que d'utiliser le tableau real[][] intersections.

Figure asymptote 90d68c038f0a16d87b37d7699ff22025
*** 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. size(150);
  2. pair a=(-1,-1), b=(1,1);
  3. real angle=60;
  4. pair centre=((a.x+b.x)/2, (4*a.y+3*b.y)/7),
  5.     p1=((3*a.x+b.x)/4, (3*a.y+b.y)/4),
  6.     p2=(a.x, centre.y),
  7.     p3=(p1.x, p2.y+centre.y-p1.y);
  8. path f1=centre{dir(180+angle)}..{left}p1{left}..{up}p2{up}..{right}p3{right}..{dir(-angle)}cycle;
  9. path f2=rotate(-90, centre)*(centre{dir(180+angle)}..{left}p1);
  10. path f3=rotate(90, centre)*(p3{right}..{dir(-angle)}centre);
  11. real[][] t2=intersections(f1, f2);
  12. real[][] t3=intersections(f1, f3);
  13. path feuille=subpath(f1, t3[1][0], t2[1][0]);
  14. draw(feuille, 2bp+green);


Il y a plus simple ?

Sinon, plus généralement, le but du jeu était de créer des enveloppes comme dans ce sujet.

Bruno

Re: [buildcycle] Comment arranger ça ?

Posté : dim. 1 sept. 2013, 00:04
par GM
maurice a écrit :Il y a plus simple ?

Cela dépend : la forme d'une feuille... devait répondre à des critères précis ou tu as choisi une forme approximative en tâtonnant ?
Je me pose d'autres questions : pourquoi cette fonction avec deux points en paramètre ?
Si c'est censé permettre avoir des trèfles plus ou moins allongé... change l'une des coordonnées du second point... et tu verras.
Donc je me demande le pourquoi de ces points en paramètres.

Tu parles d'enveloppe : où espères voir le texte dans ce trèfle ?
Heures au format UTC+01:00
Page 1 sur 2
Powered by phpBB® Forum Software © phpBB Limited
https://www.phpbb.com/