MathemaTeX

[mumblee]

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)});

[GMaths]

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]

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);

[mumblee]

Salut Gaëtan,

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)

[GMaths]

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.

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).

[mumblee]

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+

[GMaths]

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]

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.

[mumblee]

Salut Gaëtan,

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.

[OG]

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.

[GMaths]

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.

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.

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.

[GMaths]

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.

[GMaths]

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 (11.09 Kio) Vu 310 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 (6.36 Kio) Vu 307 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]

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));

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]

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);

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]

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 (8.64 Kio) Vu 193 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.

[mumblee]

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

[GMaths]

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.

[mumblee]

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

[mumblee]

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 !