path : dans un sens et dans l'autre...

[maurice]

Bonjour, j'ai écris le code suivant :

Code : Tout sélectionner

               pair A,B,C,D,O;
           A=(0,0);
           B=(0,1);
           C=(1,1);
           D=(1,0);
           O=(A+C)/2;
                path chemin1=((A+O)/2--(B+O)/2--(O+C)/2--(O+D)/2);
                path chemin2=((O+D)/2--(O+C)/2--(B+O)/2--(A+O)/2);
      path g1,g2,g3,g4;
           g1=scale(1/2,A)*(rotate(-90,O)*chemin2);
           g2=scale(1/2,B)*chemin1;
           g3=scale(1/2,C)*chemin1;
           g4=scale(1/2,D)*(rotate(90,O)*chemin2);
      path h1=g1--g2--g3--g4;
      path p1,p2,p3,p4;
           p1=scale(1/2,A)*(rotate(-90,O)*chemin1);
           p2=scale(1/2,B)*chemin2;
           p3=scale(1/2,C)*chemin2;
           p4=scale(1/2,D)*(rotate(90,O)*chemin1);
      path h2=p4--p3--p2--p1;

Les chemins h1 et h2 sont superposables mais ne sont pas parcourus dans le même sens.
Existe-t-il une commande qui permet de passer d'un chemin h1 au chemin h2 (chemin superposable à g1 mais parcouru dans le sens contraire) ?

merci

Maurice

[GM]

Les chemins h1 et h2 sont superposables

donc quel intérêt d'en définir deux de façon aussi compliquée ?

Existe-t-il une commande qui permet de passer d'un chemin h1 au chemin h2 (chemin superposable à g1 mais parcouru dans le sens contraire) ?

passer d'un chemin à l'autre ??
g1 ??

Je n'ai pas tout compris à ce que tu essayes de faire mais reverse(nomdupath) me semble correspondre à ce que tu demandes.

Si tu veux que l'on t'aide à optimiser ton code, il faudra donner des précisions sur ce que tu veux faire.

[maurice]

Merci, ca correspond bien à ce que je cherchais.

Je n'ai pas tout compris à ce que tu essayes de faire mais reverse(nomdupath) me semble correspondre à ce que tu demandes.

C'était pour construire la courbe de Peano : Un chemin dans un carrée. On coupe de carré en 4 carrés. Dans chaque carré on construit un chemin homothétique au chemin de départ tourné de 90 ou -90 degré, puis on joint les quatre chemins et on recommence ...
Le problème était de joindre les chemins. Sans tenir compte du sens de parcours ca ne produisait pas la bonne figure.
Voici le code avec la commande reverse :

Code : Tout sélectionner

//Courbe de Peano avec Asymptote 1.91

import geometry;

//Taille de l'image
unitsize(10cm);

//Fonction récursive
void Peano(path chemin, int n) {
      pair A,B,C,D,O;
           A=(0,0);
           B=(0,1);
           C=(1,1);
           D=(1,0);
           O=(A+C)/2;
      path g1,g2,g3,g4;
           g1=scale(1/2,A)*(rotate(-90,O)*reverse(chemin));
           g2=scale(1/2,B)*chemin;
           g3=scale(1/2,C)*chemin;
           g4=scale(1/2,D)*(rotate(90,O)*reverse(chemin));
      path h=g1--g2--g3--g4;
      if (n>0) {
         Peano(h,n-1);
      }
      else draw(h);
}

//Initialisation
pair A,B,C,D,O;
     A=(0,0);
     B=(0,1);
     C=(1,1);
     D=(1,0);
     O=(A+C)/2;

draw(A--B--C--D--cycle);

path g=((A+O)/2--(B+O)/2--(O+C)/2--(O+D)/2);

int n=2;

Peano(g,n);

Je suis bien sur preneur de tout conseil pouvant améliorer le code.

Merci encore.

Maurice

[GM]

Je suis bien sur preneur de tout conseil pouvant améliorer le code.

Pas de le temps de le faire dans l'instant.

Si tu faisais cela pour t'entrainer sur Asymptote... cela ne va pas t'intéresser mais je te signale tout de même qu'il y a une certaine courbe de Hilbert qui est susceptible de t'intéresser dans les exemples de Philippe, ici.

[maurice]

Je m'entraine, je fais des fractales ...
Les exemples de Philippe sont sans doute interessants mais le L_system sera pour plus tard...
merci.
maurice

[GM]

Je suis bien sur preneur de tout conseil pouvant améliorer le code.

J'ai regardé et je n'ai pas d'amélioration à proposer.

J'ai uniquement, comme distraction, cherché à proposer une autre façon de faire.
J'ai préféré définir le path dans un carré centré en O,
pour utiliser des transformations de centre O.

*** 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

size(200);
 
//Fonction récursive
void Peano(path chemin, int n) {
    transform h=scale(.5),
              r=rotate(90),
              t=shift(-1/4,1/4), ti=inverse(t),
              s=xscale(-1);
    path p1=t*h*chemin, 
         p2=ti*r*h*chemin;
    path p=s*p2--p1--reverse(s*p1)--reverse(p2);
 
    if(n>0) Peano(p,n-1); else draw(p);
}
 
/////////////////////////////////////////
/////////////////////////////////////////
 
draw(shift(-.5,-.5)*unitsquare,blue);
 
// définition d'un path g à l'intérieur du carré 
// de centre O et de côté 1, qui vient d'être dessiné.
real k=.25;
path g=scale(k)*((-1,-1)--(-1,1)--(1,1)--(1,-1));
 
int n=4;
Peano(g,n);

[GM]

Quelques modifications pour obtenir un petit délire personnel :

*** 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

// L'exemple précédent avec quelques modifications :
// 1. un nouveau path g
// 2. le type de jonction changé dans la fonction
//    renommée "delire". <img class="smilies" src="./images/smilies/icon_e_smile.gif" alt=":-)" title="Sourire" />)
// 3. ajout d'un stylo.
 
size(200);
 
//Fonction récursive
void delire(path chemin, int n, pen stylo=red) {
    transform h=scale(.5),
              r=rotate(90),
              t=shift(-1/4,1/4), ti=inverse(t),
              s=xscale(-1);
    path p1=t*h*chemin, 
         p2=ti*r*h*chemin;
    path p=s*p2..p1..reverse(s*p1)..reverse(p2);
 
    if(n>0) delire(p,n-1); else draw(p,stylo);
}
 
/////////////////////////////////////////
/////////////////////////////////////////
 
// définition d'un path g à l'intérieur du carré 
// de centre O et de côté 1.
real k=.2;
path g=scale(k)*((-1,-1){NNW}..(0,1)..{SSE}(1,-1));
 
int n=3;
delire(g,n);
 
shipout(bbox(10));

[projetmbc]

Très joli tout ceci...

[maurice]

Merci pour les exemples qui m'ont permis de découvrir 3 transformation que je ne connaissais pas :
scale(x); xscale(a); inverse();

Maurice

[GM]

Merci pour les exemples qui m'ont permis de découvrir 3 transformation que je ne connaissais pas :
scale(x); xscale(a); inverse();

Les transformations de base :

6.4 Transforms

Asymptote makes extensive use of affine transforms. A pair (x,y) is transformed by the transform t=(t.x,t.y,t.xx,t.xy,t.yx,t.yy) to (x’,y’), where

Code : Tout sélectionner

x’ = t.x + t.xx * x + t.xy * y
y’ = t.y + t.yx * x + t.yy * y

This is equivalent to the PostScript transformation [t.xx t.yx t.xy t.yy t.x t.y].

Transforms can be applied to pairs, guides, paths, pens, strings, transforms, frames, and pictures by multiplication (via the binary operator *) on the left (see [circle], page 30 for an example).

Transforms can be composed with one another and inverted with the function

Code : Tout sélectionner

transform inverse(transform t); 

they can also be raised to any integer power with the ^ operator.

The built-in transforms are :

Code : Tout sélectionner

transform identity();

the identity transform;

Code : Tout sélectionner

transform shift(pair z);

translates by the pair z;

Code : Tout sélectionner

transform shift(real x, real y);

translates by the pair (x,y);

Code : Tout sélectionner

transform xscale(real x);

scales by x in the x direction;

Code : Tout sélectionner

transform yscale(real y);

scales by y in the y direction;

Code : Tout sélectionner

transform scale(real s);

scale by s in both x and y directions;

Code : Tout sélectionner

transform scale(real x, real y);

scale by x in the x direction and by y in the y direction;

Code : Tout sélectionner

transform slant(real s);

maps (x,y) –> (x+s*y,y);

Code : Tout sélectionner

transform rotate(real angle, pair z=(0,0));

rotates by angle in degrees about z;

Code : Tout sélectionner

transform reflect(pair a, pair b);

reflects about the line a--b.

The implicit initializer for transforms is identity(). The routines shift(transform t) and shiftless(transform t) return the transforms (t.x,t.y,0,0,0,0) and (0,0,t.xx,t.xy,t.yx,t.yy) respectively.

Les transformations ajoutées par l'extension geometry :

transform hprojection(line,bool)
transform projection(line)
transform projection(line,line,bool)
transform projection(point,point)
transform projection(point,point,point,point,bool)
transform reflect(line)
transform reflect(line,line)
transform rotate(explicit vector)
transform scale(real,line,line,bool)
transform scale(real,point)
transform scale(real,point,point,point,point,bool)
transform scaleO(real)
transform vprojection(line,bool)
transform xscale(real,point)
transform xscaleO(real)
transform yscale(real,point)
transform yscaleO(real)
transforms rotateO(real)

On les trouve dans l'index ici.


A ce propos, tu utilisais une syntaxe pour scale que l'on doit à geometry mais par ailleurs, tu n'utilises pas la structure point de Philippe.
Je t'ai proposé des exemples sans geometry, mais si je devais l'utiliser, j'en profiterais pour utiliser le type point plutôt que le type pair.