Structures utilisateurs et tableaux

Tout ce qui concerne l'utilisation ou l'installation d'Asymptote.

Modérateur: gdm_asy

Règles du forum
Merci d'éviter le style SMS dans vos messages et de penser à utiliser la fonction Recherche avant de poster un message. Pour joindre des fichiers à vos messages, consulter ce sujet.
> Penser à utiliser les balises Code pour poster du code.

Structures utilisateurs et tableaux

Messagepar mumblee » Lundi 08 Février 2010, 20:48

Bonsoir,

J'expérimente de nouvelles choses avec Asymptote : l'utilisation de "struct". Je ne comprends pas pourquoi dans l'exemple suivant la première déclaration fonctionne mais pas la deuxième. Quelqu'un peut-il m'éclairer ? Merci.

Code: Tout sélectionner
import three;

struct Cube1 {
  triple avant;
  triple droite;

  void operator init(triple avant, triple droite) {
    this.avant=avant;
    this.droite=droite;
  }
}

struct Cube2 {
  Cube1[] cube;

  void operator init(Cube1[] cube) {
    this.cube[0]=cube[0];
    this.cube[1]=cube[1];
    this.cube[2]=cube[2];
    this.cube[3]=cube[3];
    this.cube[4]=cube[4];
    this.cube[5]=cube[5];
    this.cube[6]=cube[6];
    this.cube[7]=cube[7];
  }
}

// 1. Déclaration qui fonctionne
// Cube1[] c={Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y)};
// Cube2 cc=Cube2(c);

// 2. Déclaration qui ne fonctionne pas (tentative d'emboîter les deux précédentes)
Cube2 c=Cube2({Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y)});
Fabrice Eudes
mumblee
Déca-utilisateur
 
Messages: 32
Inscription: Lundi 07 Janvier 2008, 20:39
Localisation: Académie de Lille (chez les ch'ti!)
Statut actuel: Actif et salarié | Enseignant

Publicité

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Lundi 08 Février 2010, 23:24

mumblee a écrit:J'expérimente de nouvelles choses avec Asymptote : l'utilisation de "struct".

En lisant cela, cela m'a fait sourire car pas plus tard que ce matin, je me suis dit que je ne l'avais utilisé qu'une seule fois et j'ai créé une catégorie de plus pour mettre des exemples à ce sujet...
Je ne peux pas tester maintenant mais je regarderai demain matin, si personne ne t'a répondu avant.
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Mardi 09 Février 2010, 00:14

GMaths a écrit:Je ne peux pas tester maintenant ...


Finalement, j'ai pu ce soir.

Je ne sais pas trop ce que tu veux faire, apparemment tu t'attaques à des choses compliquées (ce que j'avais utilisé pour probabilitytree c'était plus simple)...
... mais j'ai bidouillé et j'ai une suggestion :

J'obtiens la même chose :

Code: Tout sélectionner
Cube1[] c={Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y)};
Cube2 cc=Cube2(c);
write(cc.cube[4].avant);


et là :

Code: Tout sélectionner
Cube2 cc=Cube2(new Cube1[] {Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y)});
write(cc.cube[4].avant);
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar mumblee » Mardi 09 Février 2010, 10:01

Salut Gaëtan,

GMaths a écrit:Je ne sais pas trop ce que tu veux faire, apparemment tu t'attaques à des choses compliquées

Non, non, c'est pas mon genre, je ne suis pas du tout un expert en programmation. J'essaie juste d'écrire des procédures pour manipuler des rubik's cube.

mais j'ai bidouillé et j'ai une suggestion :
J'obtiens la même chose :
[...]
Code: Tout sélectionner
Cube2 cc=Cube2(new Cube1[] {Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y),Cube1(X,Y)});
write(cc.cube[4].avant);

Ah ! Donc c'est le new Cube1[] qu'il me manquait. Je pensais que les constructeurs étaient justement là pour simplifier la déclaration de nouveaux objets ?!

Si un connaisseur de la programmation objet / asymptote peut nous conseiller plus simple... En attendant, j'adopte ta solution !

PS : dès que ça ressemble à quelque chose, je t'envoie le bébé, tu pourras ajouter à tes exemples si tu veux (mais ce sera peut-être un peu long comme exemple de code :? Tu jugeras)
Fabrice Eudes
mumblee
Déca-utilisateur
 
Messages: 32
Inscription: Lundi 07 Janvier 2008, 20:39
Localisation: Académie de Lille (chez les ch'ti!)
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Mardi 09 Février 2010, 10:18

mumblee a écrit:Ah ! Donc c'est le new Cube1[] qu'il me manquait. Je pensais que les constructeurs étaient justement là pour simplifier la déclaration de nouveaux objets ?!

Les constructeurs ? Tu veux dire : les structures ?
Je ne pense pas que leur vocation est de faciliter la syntaxe des déclarations : l'intérêt est dans la manipulation d'objets et dans l'héritage.

mumblee a écrit:Si un connaisseur de la programmation objet / asymptote peut nous conseiller plus simple... En attendant, j'adopte ta solution !

Si tu ne veux pas faire deux déclarations distinctes, j'ai le sentiment que tu n'auras pas plus simple.
Il y a cette contrainte de l'utilisation de l'opérateur new dès lors où tu as un tableau en argument, pour un problème de déclaration et de réservation de mémoire : tu devrais avoir des précisions sur cet opérateur en faisant des recherches sur le c++. (Je parle sous le contrôle des éventuels spécialistes du c++ que j'ai pratiqué il y a longtemps, trop longtemps pour ma petite mémoire à court terme).
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar mumblee » Mardi 09 Février 2010, 10:36

GMaths a écrit:Les constructeurs ? Tu veux dire : les structures ?

Non, je fais référence au "constructor function" de la doc officielle, mais c'est peut-être un néologisme ou une françisation malheureuse. Extrait :
If, in the body of a structure, Asymptote encounters the definition of a function of
the form void operator init(args ), it implicitly defines a constructor function of the
arguments args that uses the void operator init function to initialize a new instance
of the structure.

Donc j'aimerais bien avoir ce constructeur dans la déclaration de mon Cube2 comme je l'ai pour le Cube1, mais ne te casse pas trop la tête sur ça.
Il y a cette contrainte de l'utilisation de l'opérateur new dès lors où tu as un tableau en argument, pour un problème de déclaration et de réservation de mémoire : tu devrais avoir des précisions sur cet opérateur en faisant des recherches sur le c++. (Je parle sous le contrôle des éventuels spécialistes du c++ que j'ai pratiqué il y a longtemps, trop longtemps pour ma petite mémoire à court terme).

Ok. Moi, du c++ j'en ai jamais fait, j'apprends sur le tas -et c'est pas évident-

a+
Fabrice Eudes
mumblee
Déca-utilisateur
 
Messages: 32
Inscription: Lundi 07 Janvier 2008, 20:39
Localisation: Académie de Lille (chez les ch'ti!)
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Mardi 09 Février 2010, 21:49

GMaths a écrit:pas plus tard que ce matin, je me suis dit que je ne l'avais utilisé qu'une seule fois et j'ai créé une catégorie de plus pour mettre des exemples à ce sujet...

Je viens d'en mettre trois premiers exemples. : deux simples et un, un peu plus compliqué (pour lequel, j'ai déjà galéré donc des très compliqués, ce sera pour plus tard.).
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Mardi 09 Février 2010, 22:35

mumblee a écrit:J'essaie juste d'écrire des procédures pour manipuler des rubik's cube.

J'ai testé rapidement ce que tu m'as envoyé. Deux remarques, tout de suite :
  • une suggestion pour mieux voir le cube : currentlight=nolight;
  • La déclaration de l'exemple me semble compliquée : la boucle "for..." d'initialisation est sûrement une procédure qui pourrait être dans la structure.
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar mumblee » Mercredi 10 Février 2010, 11:08

Salut Gaëtan,

GMaths a écrit:J'ai testé rapidement ce que tu m'as envoyé. Deux remarques, tout de suite :
  • une suggestion pour mieux voir le cube : currentlight=nolight;
  • La déclaration de l'exemple me semble compliquée : la boucle "for..." d'initialisation est sûrement une procédure qui pourrait être dans la structure.

Tout à fait d'accord pour la lumière. Où peut-on trouver de la doc à ce sujet ? Je n'ai rien trouvé dans la doc officielle. Faut aller voir le source ? Quel module ? (si tu ne sais pas, je ferais un joyeux "grep" :) )
Et aussi d'accord pour la déclaration de l'exemple, c'est d'ailleurs ce qui est à l'origine de ce fil ; mais en lisant tes exemples, je pense que j'avais mal écrit ma fonction constructeur. Je vais essayer de simplifier.

merci.
Fabrice Eudes
mumblee
Déca-utilisateur
 
Messages: 32
Inscription: Lundi 07 Janvier 2008, 20:39
Localisation: Académie de Lille (chez les ch'ti!)
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar OG » Mercredi 10 Février 2010, 11:25

Bonjour

Je suis incompétent dans cette histoire.
Aller voir les codes sources des modules asymptote, comme geometry, doit pouvoir
aider.
Que veux-tu faire exactement avec le cube ?

O.G.
OG
Modérateur
 
Messages: 2285
Inscription: Lundi 12 Mars 2007, 11:20
Localisation: Rouen
Statut actuel: Actif et salarié | Maître de conférence

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Mercredi 10 Février 2010, 12:56

mumblee a écrit:Tout à fait d'accord pour la lumière. Où peut-on trouver de la doc à ce sujet ? Je n'ai rien trouvé dans la doc officielle. Faut aller voir le source ? Quel module ? (si tu ne sais pas, je ferais un joyeux "grep" :) )
La commande pour supprimer la lumière, je te l'ai donnée.

mumblee a écrit:Et aussi d'accord pour la déclaration de l'exemple, c'est d'ailleurs ce qui est à l'origine de ce fil ; mais en lisant tes exemples, je pense que j'avais mal écrit ma fonction constructeur. Je vais essayer de simplifier.


Tu peux carrément définir des procédures internes à la structure, qui te recalculeront l'état du cube.

Avec des notations du style f(front), b(back), r(right), l(left), u(up), d(down), tu dois pouvoir obtenir des syntaxes aussi simples que :
Code: Tout sélectionner
Cube c=cube(3); // déclaration d'un cube de dimension 3
c.f(1); // rotation de la face de devant, de 1 quart de tour dans le sens horaire
c.r(2); // rotation de la face de droite d'un demi-tour
c.d(-1); //rotation de la face du dessous, de 1 quart de tour dans le sens anti-horaire

voire une fonction avec une liste de mouvements en paramètre : c.move({f(1),r(2),d(-1)})....... sous réserve qu'une telle notation soit possible.

OG a écrit:Que veux-tu faire exactement avec le cube ?O.G.

Il a créé un fichier Rubik.asy qui permet d'obtenir un Rubik's cube dans un état donné, après, éventuellement, des rotations de ses faces, que l'on peut spécifier.
Dernière édition par GMaths le Vendredi 12 Février 2010, 11:26, édité 2 fois.
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Mercredi 10 Février 2010, 14:30

mumblee a écrit:Je vais essayer de simplifier.

J'ai un peu peur que cela change toute ta façon de faire... mais je ne pense pas qu'il soit intéressant de tracer les n^3 cubes... puisque, pour chacun, au plus 3 faces sont visibles.
Si je m'étais attaquer à ton défi, je me serais demandé s'il ne fallait pas plutôt

  • créer une structure FACE (dont chaque instance retiendrait les couleurs la composant), puis une structure CUBE, constituée de 6 instances de FACE.
  • ou créer une structure COULEUR (dont chaque instance retiendrait la position sur le cube des n^2 "carrés" de la couleur concernée), puis une structure CUBE, constituée de 6 instances de COULEUR.

Mais je te dis cela, de ma fenêtre :-), sans avoir réfléchi... aux facilités et/ou inconvénients d'une telle façon de faire.
Dernière édition par GMaths le Vendredi 12 Février 2010, 11:27, édité 1 fois.
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Jeudi 11 Février 2010, 01:53

GMaths a écrit:Mais je te dis cela, de ma fenêtre :-), sans avoir réfléchi...


depuis, j'ai un peu réfléchi... mais un peu seulement pour donner cela :

2010-02-11_110920.png
2010-02-11_110920.png (11.09 Kio) Vu 1119 fois


Code: Tout sélectionner
import three;
currentprojection=perspective(camera=(4,4,3),up=Z);
currentlight=nolight;

pen[]    listecouleurs={red,blue,.95white,orange,.5green,yellow};
triple[] listenormales={X,Y,Z,-X,-Y,-Z};

struct FACE { int dim;
              triple n;
              int[][] c;
              void operator init(int dim, triple n, int[][] c=new int[][]) {
                this.dim=dim;
                this.n=n;
                this.c=c;
              }
              void dessinerface(triple n, bool num=false) {
                transform3 t1,t2,h=shift((0,0,0))*scale3(1.1)*shift(-(0,0,0));
                for(int i=0; i<dim; ++i)
                  for(int j=0; j<dim; ++j){
                    pen couleur=listecouleurs[this.c[i][j]];
                    real x=i-(dim-1)/2, y=j-(dim-1)/2;
                    if(n==X) t1=shift(dim/2,x,-y)*rotate(90,Y);
                    if(n==Y) t1=shift(-x,dim/2,-y)*rotate(90,X);
                    if(n==Z) t1=shift(y,x,dim/2);
                    if(n==-X) t1=shift(-dim/2,-x,y)*rotate(90,Y);
                    if(n==-Y) t1=shift(x,-dim/2,y)*rotate(90,X);
                    if(n==-Z) t1=shift(-y,-x,-dim/2);
                    t2=t1*scale3(.95)*shift(-.5,-.5,0);
                    draw(surface(t2*unitsquare3),couleur);
                    if(num==true) label(YZ()*scale3(0.03)*format("$%i$",1+dim*i+j),h*t2*(0.5,0.5,0));
                  }
              }
}
struct CUBE { int dim;
              FACE[] f;
              void operator init(int dim=3)
              {
                this.dim=dim;
                int[][][] coul=new int[6][dim][dim];
                for(int col=0; col<6; ++col)for(int i=0; i<dim; ++i)for(int j=0; j<dim; ++j) coul[col][i][j]=col;
                for(int i=0; i<6; ++i) this.f[i]=FACE(dim,n=listenormales[i],coul[i]);
              }
              void dessinercube(bool num=false) {
                   draw(shift(-.499this.dim,-.499this.dim,-.499this.dim)*scale3(.998dim)*unitcube,black);
                   for(int i=0; i<6; ++i) {
                     this.f[i].dessinerface(this.f[i].n,num=num);
                   }
              }
}
CUBE c=CUBE(dim=3);
c.dessinercube(num=true);


num=true c'est pour numéroter les facettes... et permettre de réfléchir à la suite : écrire les procédures de rotation.
La suite... peut-être à la saint glinglin... :-), peut-être jamais car l'intérêt était de montrer des structures différentes.
Si je me décide à continuer, je vais probablement laisser tomber la possibilité de choisir dim pour me contenter du choix par défaut dim=3, car cela offre des possibilités particulières d'écrire les procédures manquantes.

AJOUT :

avec cette variante de struct CUBE :

Code: Tout sélectionner
struct CUBE { int dim;
              FACE[] f;
              void operator init(int dim, FACE[] f=new FACE[6]) {
                this.dim=dim;
                this.f=f;
              }
              void dessinercube() {
                   draw(shift(-.499this.dim,-.499this.dim,-.499this.dim)*scale3(.998dim)*unitcube,black);
                   for(int i=0; i<6; ++i) {
                     write(this.f[i].n);
                     this.f[i].dessinerface(this.f[i].n);
                   }
              }
}


on peut avoir ce type d'appel :

Code: Tout sélectionner
CUBE moncube=CUBE(dim=3,
                  new FACE[] {FACE(dim=3,n=X,new int[][] {{0,0,0},{0,0,0},{1,0,0}}), // 0 à 5 pour le choix des couleurs 
                              FACE(dim=3,n=Y,new int[][] {{2,1,1},{1,1,1},{1,1,1}}), // listecouleurs={red,blue,.95white,orange,.5green,yellow}
                              FACE(dim=3,n=Z,new int[][] {{2,2,2},{2,2,2},{2,2,0}}),
                              FACE(dim=3,n=-X,new int[][] {{3,3,3},{3,3,3},{3,3,3}}),
                              FACE(dim=3,n=-Y,new int[][] {{4,4,4},{4,4,4},{4,4,4}}),
                              FACE(dim=3,n=-Z,new int[][] {{5,5,5},{5,5,5},{5,5,5}}),
                              });
moncube.dessinercube();


pour obtenir ceci :

2010-02-11_112038.png
2010-02-11_112038.png (6.36 Kio) Vu 1116 fois


La syntaxe d'appel est simplifiable et on peut aussi envisager d'avoir les deux possibilités d'initialisation dans la structure CUBE.
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Jeudi 11 Février 2010, 13:14

Fabrice, ton sujet (rubik's cube) était une bonne idée :-) : un très bon sujet pour s'entrainer sur les structures.

Je parlais des deux initialisations possibles dans la même structure... voilà :

Code: Tout sélectionner
import three;
currentprojection=perspective(camera=(4,5,3),up=Z);
currentlight=nolight;

pen[]    listecouleurs={red,blue,.95white,orange,.5green,yellow};
triple[] listenormales={X,Y,Z,-X,-Y,-Z};

struct FACE { int dim;
              triple n;
              int[][] c;
              void operator init(int dim, triple n, int[][] c=new int[][]) {
                this.dim=dim;
                this.n=n;
                this.c=c;
              }
              void dessinerface(triple n, bool num=false,triple pos) {
                transform3 t1,t2,h=shift((0,0,0))*scale3(1.1)*shift(-(0,0,0));
                for(int i=0; i<dim; ++i)
                  for(int j=0; j<dim; ++j){
                    pen couleur=listecouleurs[this.c[i][j]];   
                    real x=i-(dim-1)/2, y=j-(dim-1)/2;
                    if(n==X) t1=shift(dim/2,x,-y)*rotate(90,Y);
                    if(n==Y) t1=shift(-x,dim/2,-y)*rotate(90,X);
                    if(n==Z) t1=shift(y,x,dim/2);
                    if(n==-X) t1=shift(-dim/2,-x,y)*rotate(90,Y);
                    if(n==-Y) t1=shift(x,-dim/2,y)*rotate(90,X);
                    if(n==-Z) t1=shift(-y,-x,-dim/2);
                    t2=t1*scale3(.95)*shift(-.5,-.5,0);
                    draw(surface(shift(pos)*t2*unitsquare3),couleur);
                    if(num==true) label(shift(pos)*YZ()*scale3(0.03)*format("$%i$",1+dim*i+j),h*t2*(0.5,0.5,0));
                  }
              }
}
struct CUBE { int dim;
              FACE[] f;
              void operator init(int dim=3, FACE[] f) {
                this.dim=dim;
                this.f=f;
              }
              void operator init(int dim=3)
              {
                this.dim=dim;
                int[][][] coul=new int[6][dim][dim];
                for(int col=0; col<6; ++col)for(int i=0; i<dim; ++i)for(int j=0; j<dim; ++j) coul[col][i][j]=col;
                for(int i=0; i<6; ++i) this.f[i]=FACE(dim,n=listenormales[i],coul[i]);
              }
              void dessinercube(bool num=false,triple pos=(0,0,0)) {
                   draw(shift(pos)*shift(-.499this.dim,-.499this.dim,-.499this.dim)*scale3(.998dim)*unitcube,black);
                   for(int i=0; i<6; ++i) {
                     this.f[i].dessinerface(this.f[i].n,num=num,pos=pos);
                   }
              }
}
CUBE c1=CUBE(dim=3);
c1.dessinercube(num=true);

CUBE c2=CUBE(dim=3,
                  new FACE[] {FACE(dim=3,n=X,new int[][] {{0,0,0},{0,0,0},{1,0,0}}),
                              FACE(dim=3,n=Y,new int[][] {{2,1,1},{1,1,1},{1,1,1}}),
                              FACE(dim=3,n=Z,new int[][] {{2,2,2},{2,2,2},{2,2,0}}),
                              FACE(dim=3,n=-X,new int[][] {{3,3,3},{3,3,3},{3,3,3}}),
                              FACE(dim=3,n=-Y,new int[][] {{4,4,4},{4,4,4},{4,4,4}}),
                              FACE(dim=3,n=-Z,new int[][] {{5,5,5},{5,5,5},{5,5,5}}),
                              });
c2.dessinercube(pos=(0,4,0));


2010-02-11_130925.png


Je n'ai pas encore mis la possibilité d'orienter le cube, sans toucher à l'angle de vue : la façon de positionner (voire de définir) le cube sera probablement à revoir si on souhaite pouvoir en mettre plusieurs avec des orientations possibles dans une même scène faisant intervenir d'autres objets.
On pourrait passer des angles en paramètres... mais ne vaudrait-il pas mieux (si c'est possible) que cela soit un objet auquel on pourrait appliquer les transformations 3D ?
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Jeudi 11 Février 2010, 22:17

Comme j'avais quelques minutes... je propose une solution rapide pour l'orientation :

j'ai opté pour la solution de facilité : me contenter d'ajouter des paramètres alphax, alphay, alphaz pour pouvoir tourner chaque cube (par rapport aux trois axes de coordonnées) avant de le translater de la position (0,0,0) à la position définie par le paramètre pos.

Code: Tout sélectionner
import three;
currentprojection=perspective(camera=(4,5,3),up=Z);
currentlight=nolight;

pen[]    listecouleurs={red,blue,.95white,orange,.5green,yellow};
triple[] listenormales={X,Y,Z,-X,-Y,-Z};

struct FACE { int dim;   
              triple n;
              int[][] c;
              void operator init(int dim, triple n, int[][] c=new int[][]) {
                this.dim=dim;
                this.n=n;
                this.c=c;
              }
              void dessinerface(triple n, bool num=false,triple pos,real alphax=0, real alphay=0, real alphaz=0) {
                transform3 t1,t2,
                           h=shift((0,0,0))*scale3(1.1)*shift(-(0,0,0)),
                           trrr=shift(pos)*rotate(alphaz,Z)*rotate(alphay,Y)*rotate(alphax,X);
                for(int i=0; i<dim; ++i)
                  for(int j=0; j<dim; ++j){
                    pen couleur=listecouleurs[this.c[i][j]];   
                    real x=i-(dim-1)/2, y=j-(dim-1)/2;
                    if(n==X) t1=shift(dim/2,x,-y)*rotate(90,Y);
                    if(n==Y) t1=shift(-x,dim/2,-y)*rotate(90,X);
                    if(n==Z) t1=shift(y,x,dim/2);
                    if(n==-X) t1=shift(-dim/2,-x,y)*rotate(90,Y);
                    if(n==-Y) t1=shift(x,-dim/2,y)*rotate(90,X);
                    if(n==-Z) t1=shift(-y,-x,-dim/2);
                    t2=t1*scale3(.95)*shift(-.5,-.5,0);
                    draw(surface(trrr*t2*unitsquare3),couleur);
                    if(num==true) label(trrr*YZ()*scale3(0.03)*format("$%i$",1+dim*i+j),h*t2*(0.5,0.5,0));
                  }
              }
}
struct CUBE { int dim;
              FACE[] f;
              void operator init(int dim=3, FACE[] f) {
                this.dim=dim;
                this.f=f;
              }
              void operator init(int dim=3)
              {
                this.dim=dim;
                int[][][] coul=new int[6][dim][dim];
                for(int col=0; col<6; ++col)for(int i=0; i<dim; ++i)for(int j=0; j<dim; ++j) coul[col][i][j]=col;
                for(int i=0; i<6; ++i) this.f[i]=FACE(dim,n=listenormales[i],coul[i]);
              }
              void dessinercube(bool num=false,triple pos=(0,0,0),real alphax=0, real alphay=0, real alphaz=0) {
                   transform3 trrr=shift(pos)*rotate(alphaz,Z)*rotate(alphay,Y)*rotate(alphax,X);
                   draw(trrr*shift(-.499this.dim,-.499this.dim,-.499this.dim)*scale3(.998dim)*unitcube,black);
                   for(int i=0; i<6; ++i) {
                     this.f[i].dessinerface(this.f[i].n,num=num,pos=pos,alphax=alphax,alphay=alphay,alphaz=alphaz);
                   }
              }
}
CUBE c1=CUBE(dim=4);
c1.dessinercube(num=true);

CUBE c2=CUBE(dim=3,
                  new FACE[] {FACE(dim=3,n=X,new int[][] {{0,0,0},{0,0,0},{0,0,0}}), // couleurs de 0 à 5 dans la liste suivante :
                              FACE(dim=3,n=Y,new int[][] {{1,1,1},{1,1,1},{1,1,1}}), // listecouleurs={red,blue,.95white,orange,.5green,yellow};
                              FACE(dim=3,n=Z,new int[][] {{3,2,2},{2,2,2},{2,2,2}}),
                              FACE(dim=3,n=-X,new int[][] {{3,3,3},{3,3,3},{3,3,4}}),
                              FACE(dim=3,n=-Y,new int[][] {{4,4,2},{4,4,4},{4,4,4}}),
                              FACE(dim=3,n=-Z,new int[][] {{5,5,5},{5,5,5},{5,5,5}}),
                              });
c2.dessinercube(pos=(0,5,0),alphay=30,alphaz=135);


2010-02-11_221250.png


Il reste à ajouter les procédures pour tourner les faces... ce sera peut-être pour plus tard, peut-être pour jamais... car je ne fais cela que pour m'amuser, sans aucun but autre que celui d'apprendre un peu mieux Asymptote... et donc tout le reste est prioritaire.
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Vendredi 12 Février 2010, 10:55

Fabrice, je viens de re-tester ta version : la première fois, je m'étais contenté de tracer un cube.
J'avais sous-estimé le fait qu'en déclarant le cube en tant que picture, on pourrait lui appliquer les transformations 3d... car je n'avais tout simplement encore jamais déclaré de picture en 3d : je trouve que le mot picture n'est pas très adapté dans ce cas : quelque chose comme object serait plus évocateur il me semble.

Code: Tout sélectionner
RotationCube(c2,Y,1);
add(DessinerCube(c1),(0,0,0));
add(rotate(45,Z)*DessinerCube(c2),(.2,0,0));


2010-02-12_104232.png
2010-02-12_104232.png (8.64 Kio) Vu 1002 fois


A part les améliorations déjà évoquées qui seraient éventuellement à apporter (simplifier la déclaration d'un nouveau cube, éviter de tracer des faces non vues), sinon cela a l'air de plutôt bien fonctionner ! :-) Peut-être revoir le problème de la taille des cubes car dans l'exemple précédent, j'ai eu du mal à trouver le réglage pour les placer : est-ce qu'un cube de dimension n ne devrait pas mesurer par défaut n de côté ?

NB : j'ai édité deux de mes messages précédents pour corriger des choses.
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar mumblee » Mardi 09 Mars 2010, 17:18

GMaths a écrit:La commande pour supprimer la lumière, je te l'ai donnée.

Certes, mais dans adobe reader, avec prc, on voit bien qu'il y a différents types de lumières possibles. Est-ce tranposé en différentes options dans asymptote ? Je veux dire que j'aimerais bien en savoir plus sur les commandes light et currentlight, mais qu'il n'y a rien dans la doc officielle à leur propos (je viens de compiler la 1.91).

Je prends le temps de lire tes autres messages et je réponds... Désolé, ça fait un moment que je n'étais pas venu sur cette page :?
Fabrice Eudes
mumblee
Déca-utilisateur
 
Messages: 32
Inscription: Lundi 07 Janvier 2008, 20:39
Localisation: Académie de Lille (chez les ch'ti!)
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar GMaths » Mardi 09 Mars 2010, 19:04

mumblee a écrit:
GMaths a écrit:La commande pour supprimer la lumière, je te l'ai donnée.

Certes, mais dans adobe reader, avec prc, on voit bien qu'il y a différents types de lumières possibles. Est-ce tranposé en différentes options dans asymptote ? Je veux dire que j'aimerais bien en savoir plus sur les commandes light et currentlight, mais qu'il n'y a rien dans la doc officielle à leur propos (je viens de compiler la 1.91).


Il faut bien souvent regarder les sources pour avoir des infos : en l'occurrence three_light.asy pour ta question.
Peu de types de lumière sont définis : voir la fin de fichier.
Des possibilités nommées sont :

Code: Tout sélectionner
currentlight=Headlamp;
currentlight=White;
currentlight=Viewport;
currentlight=nolight;


... après il faut aller définir soi-même les sources de lumière avec la commande light. Voir les exemples officiels.


On peut avoir des choses du genre :
Code: Tout sélectionner
currentlight=light(gray(0.5),specularfactor=3,viewport=false,
                   (0.5,-0.5,-0.25),(0.5,0.5,0.25),(0.5,0.5,1),(-0.5,-0.5,-1));


Je suis d'accord avec toi : ce n'est pas facile à régler... et le rendu n'est pas toujours satisfaisant.
Et je ne pense pas qu'il y aura beaucoup de monde pour t'aider sur le sujet pour la raison précédente.
GMaths
Exa-utilisateur
 
Messages: 2031
Inscription: Lundi 01 Octobre 2007, 09:20
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar mumblee » Mardi 09 Mars 2010, 19:59

GMaths a écrit:Je parlais des deux initialisations possibles dans la même structure... voilà :

Code: Tout sélectionner
struct CUBE { int dim;
              FACE[] f;
              void operator init(int dim=3, FACE[] f) {
                this.dim=dim;
                this.f=f;
              }
              void operator init(int dim=3)
              {
                this.dim=dim;
                int[][][] coul=new int[6][dim][dim];
                for(int col=0; col<6; ++col)for(int i=0; i<dim; ++i)for(int j=0; j<dim; ++j) coul[col][i][j]=col;
                for(int i=0; i<6; ++i) this.f[i]=FACE(dim,n=listenormales[i],coul[i]);
              }
}


Ah oui, c'est chouette ça, je repique :)
Fabrice Eudes
mumblee
Déca-utilisateur
 
Messages: 32
Inscription: Lundi 07 Janvier 2008, 20:39
Localisation: Académie de Lille (chez les ch'ti!)
Statut actuel: Actif et salarié | Enseignant

Re: [Asymptote] Structures utilisateurs et tableaux

Messagepar mumblee » Mardi 09 Mars 2010, 20:40

GMaths a écrit:Il faut bien souvent regarder les sources pour avoir des infos : en l'occurrence three_light.asy pour ta question.
... après il faut aller définir soi-même les sources de lumière avec la commande light. Voir les exemples officiels.
Et je ne pense pas qu'il y aura beaucoup de monde pour t'aider sur le sujet pour la raison précédente.

Ta réponse est amplement suffisante, merci beaucoup !
Fabrice Eudes
mumblee
Déca-utilisateur
 
Messages: 32
Inscription: Lundi 07 Janvier 2008, 20:39
Localisation: Académie de Lille (chez les ch'ti!)
Statut actuel: Actif et salarié | Enseignant

Suivante

Retourner vers Asymptote

 


  • Articles en relation
    Réponses
    Vus
    Dernier message

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 1 invité

cron