Historique des modifications [retour]
|
11 |
Classement par ordre de difficulté croissante des solutions
|
|
Trois solutions ont été données sur le forum [mathematex](http://forum.mathematex.net/asymptote-f34/supprimer-le-scintillement-d-un-de-a-jouer-en-3d-t16837.html) dédié à Asymptote par les modérateurs `OG` et `rebouxo`. Ils m'autorisent tous deux à les reproduire ici même.
**Première solution de OG :**
C'est normal *(réponse facile)*. En effet les disques sont exactement sur la surface des faces, aucun des objets n'est positionné au dessus/au dessous...
Solution 1 : décaler de `$\varepsilon=0.001$` chaque disque dans le bon sens.
Voici le code :
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+.001)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+.001)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par OG** *(moins facile)* : dessiner réellement chaque face comme le carré privé des disques :
Asymptote peut transformer un contour 2D en une surface 3D.
C'est ce qui est fait pour les étiquettes en 3D : `bezulate` est ton ami.
@rebouxo: il y a aussi `extrude` qui peut servir..
Il faut donc construire chaque face trouée et là plus besoin du décalage de `$\varepsilon$`
Pour que `bezulate` comprenne la construction 1 carré privé d'un disque, il faut faire
un `reverse(disque)`, c'est la règle.
Voici le code :
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
// reverse est capital pour créer les trous avec bezulate
// c'est la règle : unitsquare et disque ne seront pas dans le
// même sens, donc bezulate comprend que c'est un trou
disque = scale(9a)*reverse(unitcircle),
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[]= shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a)*X), tY=shift((84a)*Y), tZ=shift((84a)*Z);
path3 facegauche[] =path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =path3(patron3,XYplane);
// draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
// les faces trouées
path[] gp6=bezulate(scale(84a)*unitsquare^^patron6);
path[] gp5=bezulate(scale(84a)*unitsquare^^patron5);
path[] gp4=bezulate(scale(84a)*unitsquare^^patron4);
path[] gp3=bezulate(scale(84a)*unitsquare^^patron3);
path[] gp2=bezulate(scale(84a)*unitsquare^^patron2);
path[] gp1=bezulate(scale(84a)*unitsquare^^patron1);
surface s1=shift((0,84a,84a))*rotate(90,Y)*rotate(90,X)*surface(gp1);
surface s2=shift(84a,0,0)*rotate(-90,Y)*surface(gp2);
surface s3=surface(gp3);
surface s4=shift((0,0,84a))*surface(gp4);
surface s5=shift((0,0,84a))*rotate(90,Y)*surface(gp5);
surface s6=shift((0,0,84a))*rotate(90,Y)*rotate(90,X)*surface(gp6);
draw(s6,red);
draw(s5,red);
draw(s4,red);
draw(s3,red);
draw(s2,red);
draw(s1,red);
![alt text][1]
**Troisième solution par rebouxo :**
La source des scintillements vient que tu as des objets plans l'un sur l'autre. Il suffit de décaler les cercles légèrement du cube pour que le scintillement disparaisse, j'ai décalé de h.
Je propose ceci comme code :
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
real h = 0.001 ;
surface cube = scale3(84*a)*unitcube ;
surface disqueX = scale3(9*a)*unitdisk ;
surface disqueY = rotate(90,Y)*scale3(9*a)*unitdisk ;
surface disqueZ = rotate(90,X)*scale3(9*a)*unitdisk ;
draw(cube, white, gray+linewidth(1bp));
surface[] face1 = {shift(42*a,42*a,84*(a+h))*disqueX} ;
surface[] face6 = {shift(14*a,14*a,-h)*disqueX,
shift(14*a,42*a,-h)*disqueX,
shift(14*a,70*a,-h)*disqueX,
shift(70*a,14*a,-h)*disqueX,
shift(70*a,42*a,-h)*disqueX,
shift(70*a,70*a,-h)*disqueX} ;
surface[] face2 = {shift(-h,14*a,14*a)*disqueY,
shift(-h,70*a,70*a)*disqueY} ;
surface[] face5 = {shift(84*(a+h),14*a,14*a)*disqueY,
shift(84*(a+h),14*a,70*a)*disqueY,
shift(84*(a+h),42*a,42*a)*disqueY,
shift(84*(a+h),70*a,14*a)*disqueY,
shift(84*(a+h),70*a,70*a)*disqueY} ;
surface[] face4 = {shift(14*a,84*(a+h),14*a)*disqueZ,
shift(14*a,84*(a+h),70*a)*disqueZ,
shift(70*a,84*(a+h),14*a)*disqueZ,
shift(70*a,84*(a+h),70*a)*disqueZ} ;
surface[] face3 = {shift(14*a,-h,14*a)*disqueZ,
shift(42*a,-h,42*a)*disqueZ,
shift(70*a,-h,70*a)*disqueZ} ;
surface[][] points = {face1,face2,face3,face4,face5,face6} ;
for(int i = 0 ; i < 6 ; ++i)
{
for(int cpt = 0 ; cpt <= i ; ++cpt)
{
draw(points[i][cpt],blue,blue) ;
}
}
La principale différence est d'utiliser systématiquement les objets 3d, plutôt que de gérer des objets plans, pour les plaquer sur le dés. Plutôt une histoire de goût, mais je soupçonne que ta méthode soit plus efficace, si il y a beaucoup d'objets. Comme je ne peux pas concaténer des surface (dommage) j'ai fait des tableaux de surface (un pour chaque face) et un tableau de ces tableaux, pour éviter des copier-coller.
Il manque des choses dans asymptote : faire des trous, des chanfreins, bref toutes choses utile pour la CAO.
**Troisième solution par OG** *(moins facile)* : dessiner réellement chaque face comme le carré privé des disques :
Asymptote peut transformer un contour 2D en une surface 3D.
C'est ce qui est fait pour les étiquettes en 3D : `bezulate` est ton ami.
@rebouxo: il y a aussi `extrude` qui peut servir..
Il faut donc construire chaque face trouée et là plus besoin du décalage de `$\varepsilon$`
Pour que `bezulate` comprenne la construction 1 carré privé d'un disque, il faut faire
un `reverse(disque)`, c'est la règle.
Voici le code :
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
// reverse est capital pour créer les trous avec bezulate
// c'est la règle : unitsquare et disque ne seront pas dans le
// même sens, donc bezulate comprend que c'est un trou
disque = scale(9a)*reverse(unitcircle),
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[]= shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a)*X), tY=shift((84a)*Y), tZ=shift((84a)*Z);
path3 facegauche[] =path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =path3(patron3,XYplane);
// draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
// les faces trouées
path[] gp6=bezulate(scale(84a)*unitsquare^^patron6);
path[] gp5=bezulate(scale(84a)*unitsquare^^patron5);
path[] gp4=bezulate(scale(84a)*unitsquare^^patron4);
path[] gp3=bezulate(scale(84a)*unitsquare^^patron3);
path[] gp2=bezulate(scale(84a)*unitsquare^^patron2);
path[] gp1=bezulate(scale(84a)*unitsquare^^patron1);
surface s1=shift((0,84a,84a))*rotate(90,Y)*rotate(90,X)*surface(gp1);
surface s2=shift(84a,0,0)*rotate(-90,Y)*surface(gp2);
surface s3=surface(gp3);
surface s4=shift((0,0,84a))*surface(gp4);
surface s5=shift((0,0,84a))*rotate(90,Y)*surface(gp5);
surface s6=shift((0,0,84a))*rotate(90,Y)*rotate(90,X)*surface(gp6);
draw(s6,red);
draw(s5,red);
draw(s4,red);
draw(s3,red);
draw(s2,red);
draw(s1,red);
![alt text][1]
[1]: http://forum.mathematex.net/download/file.php?id=4095
|
|
10 |
|
|
Trois solutions ont été données sur le forum [mathematex](http://forum.mathematex.net/asymptote-f34/supprimer-le-scintillement-d-un-de-a-jouer-en-3d-t16837.html) dédié à Asymptote par les modérateurs `OG` et `rebouxo`. Ils m'autorisent tous deux à les reproduire ici même.
**Première solution de OG :**
C'est normal (réponse facile). *(réponse facile)*. En effet les disques sont exactement sur la surface des faces, aucun des objets n'est positionné au dessus/au dessous...
Solution 1 : décaler de `$\varepsilon=0.001$` chaque disque dans le bon sens.
Voici le code :
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+.001)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+.001)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par OG** (moins facile) *(moins facile)* : dessiner réellement chaque face comme le carré privé des disques :
Asymptote peut transformer un contour 2D en une surface 3D.
C'est ce qui est fait pour les étiquettes en 3D : `bezulate` est ton ami.
@rebouxo: il y a aussi `extrude` qui peut servir..
Il faut donc construire chaque face trouée et là plus besoin du décalage de `$\varepsilon$`
Pour que `bezulate` comprenne la construction 1 carré privé d'un disque, il faut faire
un `reverse(disque)`, c'est la règle.
Voici le code :
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
// reverse est capital pour créer les trous avec bezulate
// c'est la règle : unitsquare et disque ne seront pas dans le
// même sens, donc bezulate comprend que c'est un trou
disque = scale(9a)*reverse(unitcircle),
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[]= shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a)*X), tY=shift((84a)*Y), tZ=shift((84a)*Z);
path3 facegauche[] =path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =path3(patron3,XYplane);
// draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
// les faces trouées
path[] gp6=bezulate(scale(84a)*unitsquare^^patron6);
path[] gp5=bezulate(scale(84a)*unitsquare^^patron5);
path[] gp4=bezulate(scale(84a)*unitsquare^^patron4);
path[] gp3=bezulate(scale(84a)*unitsquare^^patron3);
path[] gp2=bezulate(scale(84a)*unitsquare^^patron2);
path[] gp1=bezulate(scale(84a)*unitsquare^^patron1);
surface s1=shift((0,84a,84a))*rotate(90,Y)*rotate(90,X)*surface(gp1);
surface s2=shift(84a,0,0)*rotate(-90,Y)*surface(gp2);
surface s3=surface(gp3);
surface s4=shift((0,0,84a))*surface(gp4);
surface s5=shift((0,0,84a))*rotate(90,Y)*surface(gp5);
surface s6=shift((0,0,84a))*rotate(90,Y)*rotate(90,X)*surface(gp6);
draw(s6,red);
draw(s5,red);
draw(s4,red);
draw(s3,red);
draw(s2,red);
draw(s1,red);
![alt text][1]
**Troisième solution par rebouxo :**
La source des scintillements viens vient que tu as des objets plans l'un sur l'autre. Il suffit de décaler les cercles légèrement du cube pour que le scintillement disparaisse, j'ai décalé de h.
Je propose ceci comme code
code :
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
real h = 0.001 ;
surface cube = scale3(84*a)*unitcube ;
surface disqueX = scale3(9*a)*unitdisk ;
surface disqueY = rotate(90,Y)*scale3(9*a)*unitdisk ;
surface disqueZ = rotate(90,X)*scale3(9*a)*unitdisk ;
draw(cube, white, gray+linewidth(1bp));
surface[] face1 = {shift(42*a,42*a,84*(a+h))*disqueX} ;
surface[] face6 = {shift(14*a,14*a,-h)*disqueX,
shift(14*a,42*a,-h)*disqueX,
shift(14*a,70*a,-h)*disqueX,
shift(70*a,14*a,-h)*disqueX,
shift(70*a,42*a,-h)*disqueX,
shift(70*a,70*a,-h)*disqueX} ;
surface[] face2 = {shift(-h,14*a,14*a)*disqueY,
shift(-h,70*a,70*a)*disqueY} ;
surface[] face5 = {shift(84*(a+h),14*a,14*a)*disqueY,
shift(84*(a+h),14*a,70*a)*disqueY,
shift(84*(a+h),42*a,42*a)*disqueY,
shift(84*(a+h),70*a,14*a)*disqueY,
shift(84*(a+h),70*a,70*a)*disqueY} ;
surface[] face4 = {shift(14*a,84*(a+h),14*a)*disqueZ,
shift(14*a,84*(a+h),70*a)*disqueZ,
shift(70*a,84*(a+h),14*a)*disqueZ,
shift(70*a,84*(a+h),70*a)*disqueZ} ;
surface[] face3 = {shift(14*a,-h,14*a)*disqueZ,
shift(42*a,-h,42*a)*disqueZ,
shift(70*a,-h,70*a)*disqueZ} ;
surface[][] points = {face1,face2,face3,face4,face5,face6} ;
for(int i = 0 ; i < 6 ; ++i)
{
for(int cpt = 0 ; cpt <= i ; ++cpt)
{
draw(points[i][cpt],blue,blue) ;
}
}
La principale différence est d'utiliser systématiquement les objets 3d, plutôt que de gérer des objets plans, pour les plaquer sur le dés. Plutôt une histoire de goût, mais je soupçonne que ta méthode soit plus efficace, si il y a beaucoup d'objets. Comme je ne peux pas concaténer des surface (dommage) j'ai fait des tableaux de surface (un pour chaque face) et un tableau de ces tableaux, pour éviter des copier-coller.
Il manque des choses dans asymptote : faire des trous, des chanfreins, bref toutes choses utile pour la CAO.
[1]: http://forum.mathematex.net/download/file.php?id=4095
|
|
9 |
Amélioration du style
|
|
Trois solutions ont été données sur le forum [mathematex](http://forum.mathematex.net/asymptote-f34/supprimer-le-scintillement-d-un-de-a-jouer-en-3d-t16837.html) dédié à Asymptote par les modérateurs `OG` et `rebouxo`. Ils m'autorisent tous deux à les reproduire ici même.
**Première solution de OG :**
C'est normal (réponse facile). En effet les disques sont exactement sur la surface des faces, aucun des objets n'est positionné au dessus/au dessous...
Solution 1 (voir code ci-joint) : décaler de `$\varepsilon=0.001$` chaque disque dans le bon sens.
Voici le code :
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+.001)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+.001)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par OG**
Solution 2 OG** (moins facile) : dessiner réellement chaque face comme le carré privé des disques :
Asymptote peut transformer un contour 2D en une surface 3D.
C'est ce qui fait pour les étiquettes en 3D : `bezulate` est ton ami.
@rebouxo: il y a aussi `extrude` qui peut servir..
Il faut donc construire chaque face trouée et là plus besoin du décalage de `$\varepsilon$`
Pour que `bezulate` comprenne la construction 1 carré privé d'un disque, il faut faire
un `reverse(disque)`, c'est la règle.
Voici le code :
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
// reverse est capital pour créer les trous avec bezulate
// c'est la règle : unitsquare et disque ne seront pas dans le
// même sens, donc bezulate comprend que c'est un trou
disque = scale(9a)*reverse(unitcircle),
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[]= shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a)*X), tY=shift((84a)*Y), tZ=shift((84a)*Z);
path3 facegauche[] =path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =path3(patron3,XYplane);
// draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
// les faces trouées
path[] gp6=bezulate(scale(84a)*unitsquare^^patron6);
path[] gp5=bezulate(scale(84a)*unitsquare^^patron5);
path[] gp4=bezulate(scale(84a)*unitsquare^^patron4);
path[] gp3=bezulate(scale(84a)*unitsquare^^patron3);
path[] gp2=bezulate(scale(84a)*unitsquare^^patron2);
path[] gp1=bezulate(scale(84a)*unitsquare^^patron1);
surface s1=shift((0,84a,84a))*rotate(90,Y)*rotate(90,X)*surface(gp1);
surface s2=shift(84a,0,0)*rotate(-90,Y)*surface(gp2);
surface s3=surface(gp3);
surface s4=shift((0,0,84a))*surface(gp4);
surface s5=shift((0,0,84a))*rotate(90,Y)*surface(gp5);
surface s6=shift((0,0,84a))*rotate(90,Y)*rotate(90,X)*surface(gp6);
draw(s6,red);
draw(s5,red);
draw(s4,red);
draw(s3,red);
draw(s2,red);
draw(s1,red);
![alt text][1]
**Troisième solution par rebouxo :**
La source des scintillements viens que tu as des objets plans l'un sur l'autre. Il suffit de décaler les cercles légèrement du cube pour que le scintillement disparaisse, j'ai décalé de h.
Je propose ceci comme code
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
real h = 0.001 ;
surface cube = scale3(84*a)*unitcube ;
surface disqueX = scale3(9*a)*unitdisk ;
surface disqueY = rotate(90,Y)*scale3(9*a)*unitdisk ;
surface disqueZ = rotate(90,X)*scale3(9*a)*unitdisk ;
draw(cube, white, gray+linewidth(1bp));
surface[] face1 = {shift(42*a,42*a,84*(a+h))*disqueX} ;
surface[] face6 = {shift(14*a,14*a,-h)*disqueX,
shift(14*a,42*a,-h)*disqueX,
shift(14*a,70*a,-h)*disqueX,
shift(70*a,14*a,-h)*disqueX,
shift(70*a,42*a,-h)*disqueX,
shift(70*a,70*a,-h)*disqueX} ;
surface[] face2 = {shift(-h,14*a,14*a)*disqueY,
shift(-h,70*a,70*a)*disqueY} ;
surface[] face5 = {shift(84*(a+h),14*a,14*a)*disqueY,
shift(84*(a+h),14*a,70*a)*disqueY,
shift(84*(a+h),42*a,42*a)*disqueY,
shift(84*(a+h),70*a,14*a)*disqueY,
shift(84*(a+h),70*a,70*a)*disqueY} ;
surface[] face4 = {shift(14*a,84*(a+h),14*a)*disqueZ,
shift(14*a,84*(a+h),70*a)*disqueZ,
shift(70*a,84*(a+h),14*a)*disqueZ,
shift(70*a,84*(a+h),70*a)*disqueZ} ;
surface[] face3 = {shift(14*a,-h,14*a)*disqueZ,
shift(42*a,-h,42*a)*disqueZ,
shift(70*a,-h,70*a)*disqueZ} ;
surface[][] points = {face1,face2,face3,face4,face5,face6} ;
for(int i = 0 ; i < 6 ; ++i)
{
for(int cpt = 0 ; cpt <= i ; ++cpt)
{
draw(points[i][cpt],blue,blue) ;
}
}
La principale différence est d'utiliser systématiquement les objets 3d, plutôt que de gérer des objets plans, pour les plaquer sur le dés. Plutôt une histoire de goût, mais je soupçonne que ta méthode soit plus efficace, si il y a beaucoup d'objets. Comme je ne peux pas concaténer des surface (dommage) j'ai fait des tableaux de surface (un pour chaque face) et un tableau de ces tableaux, pour éviter des copier-coller.
Il manque des choses dans asymptote : faire des trous, des chanfreins, bref toutes choses utile pour la CAO.
[1]: http://forum.mathematex.net/download/file.php?id=4095
|
|
8 |
|
|
Trois solutions ont été données sur le forum [mathematex](http://forum.mathematex.net/asymptote-f34/supprimer-le-scintillement-d-un-de-a-jouer-en-3d-t16837.html) dédié à Asymptote par les modérateurs `OG` et `rebouxo`. Ils m'autorisent tous deux à les reproduire ici même.
**Première solution de OG :**
C'est normal (réponse facile). En effet les disques sont exactement sur la surface des faces, aucun des objets
objets n'est positionné au dessus/au dessous...
Solution 1 (voir code ci-joint) : décaler de `$\varepsilon=0.001$` chaque disque dans le bon sens.
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+.001)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+.001)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par OG**
Solution 2 (moins facile) : dessiner réellement chaque face comme le carré privé des disques :
Asymptote peut transformer un contour 2D en une surface 3D.
C'est ce qui fait pour les étiquettes en 3D : `bezulate` est ton ami.
@rebouxo: il y a aussi `extrude` qui peut servir..
Il faut donc construire chaque face trouée et là plus besoin du décalage de `$\varepsilon$`
Pour que `bezulate` comprenne la construction 1 carré privé d'un disque, il faut faire
un `reverse(disque)`, c'est la règle.
Voici le code :
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
// reverse est capital pour créer les trous avec bezulate
// c'est la règle : unitsquare et disque ne seront pas dans le
// même sens, donc bezulate comprend que c'est un trou
disque = scale(9a)*reverse(unitcircle),
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[]= shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a)*X), tY=shift((84a)*Y), tZ=shift((84a)*Z);
path3 facegauche[] =path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =path3(patron3,XYplane);
// draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
// les faces trouées
path[] gp6=bezulate(scale(84a)*unitsquare^^patron6);
path[] gp5=bezulate(scale(84a)*unitsquare^^patron5);
path[] gp4=bezulate(scale(84a)*unitsquare^^patron4);
path[] gp3=bezulate(scale(84a)*unitsquare^^patron3);
path[] gp2=bezulate(scale(84a)*unitsquare^^patron2);
path[] gp1=bezulate(scale(84a)*unitsquare^^patron1);
surface s1=shift((0,84a,84a))*rotate(90,Y)*rotate(90,X)*surface(gp1);
surface s2=shift(84a,0,0)*rotate(-90,Y)*surface(gp2);
surface s3=surface(gp3);
surface s4=shift((0,0,84a))*surface(gp4);
surface s5=shift((0,0,84a))*rotate(90,Y)*surface(gp5);
surface s6=shift((0,0,84a))*rotate(90,Y)*rotate(90,X)*surface(gp6);
draw(s6,red);
draw(s5,red);
draw(s4,red);
draw(s3,red);
draw(s2,red);
draw(s1,red);
![alt text][1]
**Troisième solution par rebouxo :**
La source des scintillements viens que tu as des objets plans l'un sur l'autre. Il suffit de décaler les cercles légèrement du cube pour que le scintillement disparaisse, j'ai décalé de h.
Je propose ceci comme code
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
real h = 0.001 ;
surface cube = scale3(84*a)*unitcube ;
surface disqueX = scale3(9*a)*unitdisk ;
surface disqueY = rotate(90,Y)*scale3(9*a)*unitdisk ;
surface disqueZ = rotate(90,X)*scale3(9*a)*unitdisk ;
draw(cube, white, gray+linewidth(1bp));
surface[] face1 = {shift(42*a,42*a,84*(a+h))*disqueX} ;
surface[] face6 = {shift(14*a,14*a,-h)*disqueX,
shift(14*a,42*a,-h)*disqueX,
shift(14*a,70*a,-h)*disqueX,
shift(70*a,14*a,-h)*disqueX,
shift(70*a,42*a,-h)*disqueX,
shift(70*a,70*a,-h)*disqueX} ;
surface[] face2 = {shift(-h,14*a,14*a)*disqueY,
shift(-h,70*a,70*a)*disqueY} ;
surface[] face5 = {shift(84*(a+h),14*a,14*a)*disqueY,
shift(84*(a+h),14*a,70*a)*disqueY,
shift(84*(a+h),42*a,42*a)*disqueY,
shift(84*(a+h),70*a,14*a)*disqueY,
shift(84*(a+h),70*a,70*a)*disqueY} ;
surface[] face4 = {shift(14*a,84*(a+h),14*a)*disqueZ,
shift(14*a,84*(a+h),70*a)*disqueZ,
shift(70*a,84*(a+h),14*a)*disqueZ,
shift(70*a,84*(a+h),70*a)*disqueZ} ;
surface[] face3 = {shift(14*a,-h,14*a)*disqueZ,
shift(42*a,-h,42*a)*disqueZ,
shift(70*a,-h,70*a)*disqueZ} ;
surface[][] points = {face1,face2,face3,face4,face5,face6} ;
for(int i = 0 ; i < 6 ; ++i)
{
for(int cpt = 0 ; cpt <= i ; ++cpt)
{
draw(points[i][cpt],blue,blue) ;
}
}
La principale différence est d'utiliser systématiquement les objets 3d, plutôt que de gérer des objets plans, pour les plaquer sur le dés. Plutôt une histoire de goût, mais je soupçonne que ta méthode soit plus efficace, si il y a beaucoup d'objets. Comme je ne peux pas concaténer des surface (dommage) j'ai fait des tableaux de surface (un pour chaque face) et un tableau de ces tableaux, pour éviter des copier-coller.
Il manque des choses dans asymptote : faire des trous, des chanfreins, bref toutes choses utile pour la CAO.
[1]: http://forum.mathematex.net/download/file.php?id=4095
|
|
7 |
Amélioration de la présentation
|
|
Trois solutions ont été données sur le forum [mathematex](http://forum.mathematex.net/asymptote-f34/supprimer-le-scintillement-d-un-de-a-jouer-en-3d-t16837.html) dédié à Asymptote par les modérateurs `OG` et `rebouxo`. Ils m'autorisent tous deux à les reproduire ici même.
**Première solution de OG :**
C'est normal (réponse facile). En effet les disques sont exactement sur la surface des faces, aucun des objets
n'est positionné au dessus/au dessous...
Solution 1 (voir code ci-joint) : décaler de `$\varepsilon=0.001$` chaque disque dans le bon sens.
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+.001)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+.001)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par OG**
Solution 2 (moins facile) : dessiner réellement chaque face comme le carré privé des disques
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+.001)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+.001)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par OG**
disques :
Asymptote peut transformer un contour 2D en une surface 3D.
C'est ce qui fait pour les étiquettes en 3D : `bezulate` est ton ami.
@rebouxo: il y a aussi `extrude` qui peut servir..
Il faut donc construire chaque face trouée et là plus besoin du décalage de `$\varepsilon$`
Pour que `bezulate` comprenne la construction 1 carré privé d'un disque, il faut faire
un `reverse(disque)`, c'est la règle.
Voici le code :
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
// reverse est capital pour créer les trous avec bezulate
// c'est la règle : unitsquare et disque ne seront pas dans le
// même sens, donc bezulate comprend que c'est un trou
disque = scale(9a)*reverse(unitcircle),
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[]= shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a)*X), tY=shift((84a)*Y), tZ=shift((84a)*Z);
path3 facegauche[] =path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =path3(patron3,XYplane);
// draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
// les faces trouées
path[] gp6=bezulate(scale(84a)*unitsquare^^patron6);
path[] gp5=bezulate(scale(84a)*unitsquare^^patron5);
path[] gp4=bezulate(scale(84a)*unitsquare^^patron4);
path[] gp3=bezulate(scale(84a)*unitsquare^^patron3);
path[] gp2=bezulate(scale(84a)*unitsquare^^patron2);
path[] gp1=bezulate(scale(84a)*unitsquare^^patron1);
surface s1=shift((0,84a,84a))*rotate(90,Y)*rotate(90,X)*surface(gp1);
surface s2=shift(84a,0,0)*rotate(-90,Y)*surface(gp2);
surface s3=surface(gp3);
surface s4=shift((0,0,84a))*surface(gp4);
surface s5=shift((0,0,84a))*rotate(90,Y)*surface(gp5);
surface s6=shift((0,0,84a))*rotate(90,Y)*rotate(90,X)*surface(gp6);
draw(s6,red);
draw(s5,red);
draw(s4,red);
draw(s3,red);
draw(s2,red);
draw(s1,red);
![alt text][1]
**Troisième solution par rebouxo :**
La source des scintillements viens que tu as des objets plans l'un sur l'autre. Il suffit de décaler les cercles légèrement du cube pour que le scintillement disparaisse, j'ai décalé de h.
Je propose ceci comme code
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
real h = 0.001 ;
surface cube = scale3(84*a)*unitcube ;
surface disqueX = scale3(9*a)*unitdisk ;
surface disqueY = rotate(90,Y)*scale3(9*a)*unitdisk ;
surface disqueZ = rotate(90,X)*scale3(9*a)*unitdisk ;
draw(cube, white, gray+linewidth(1bp));
surface[] face1 = {shift(42*a,42*a,84*(a+h))*disqueX} ;
surface[] face6 = {shift(14*a,14*a,-h)*disqueX,
shift(14*a,42*a,-h)*disqueX,
shift(14*a,70*a,-h)*disqueX,
shift(70*a,14*a,-h)*disqueX,
shift(70*a,42*a,-h)*disqueX,
shift(70*a,70*a,-h)*disqueX} ;
surface[] face2 = {shift(-h,14*a,14*a)*disqueY,
shift(-h,70*a,70*a)*disqueY} ;
surface[] face5 = {shift(84*(a+h),14*a,14*a)*disqueY,
shift(84*(a+h),14*a,70*a)*disqueY,
shift(84*(a+h),42*a,42*a)*disqueY,
shift(84*(a+h),70*a,14*a)*disqueY,
shift(84*(a+h),70*a,70*a)*disqueY} ;
surface[] face4 = {shift(14*a,84*(a+h),14*a)*disqueZ,
shift(14*a,84*(a+h),70*a)*disqueZ,
shift(70*a,84*(a+h),14*a)*disqueZ,
shift(70*a,84*(a+h),70*a)*disqueZ} ;
surface[] face3 = {shift(14*a,-h,14*a)*disqueZ,
shift(42*a,-h,42*a)*disqueZ,
shift(70*a,-h,70*a)*disqueZ} ;
surface[][] points = {face1,face2,face3,face4,face5,face6} ;
for(int i = 0 ; i < 6 ; ++i)
{
for(int cpt = 0 ; cpt <= i ; ++cpt)
{
draw(points[i][cpt],blue,blue) ;
}
}
La principale différence est d'utiliser systématiquement les objets 3d, plutôt que de gérer des objets plans, pour les plaquer sur le dés. Plutôt une histoire de goût, mais je soupçonne que ta méthode soit plus efficace, si il y a beaucoup d'objets. Comme je ne peux pas concaténer des surface (dommage) j'ai fait des tableaux de surface (un pour chaque face) et un tableau de ces tableaux, pour éviter des copier-coller.
Il manque des choses dans asymptote : faire des trous, des chanfreins, bref toutes choses utile pour la CAO.
[1]: http://forum.mathematex.net/download/file.php?id=4095
|
|
6 |
Ajout de la deuxième solution de OG, ce qui en fait 3 !
|
|
|
|
5 |
|
|
Deux solutions ont été données sur le forum [mathematex](http://forum.mathematex.net/asymptote-f34/supprimer-le-scintillement-d-un-de-a-jouer-en-3d-t16837.html) dédié à Asymptote par les modérateurs `OG` et `rebouxo`. Ils m'autorisent tous deux à les reproduire ici même.
**Première solution de OG :**
C'est normal (réponse facile). En effet les disques sont exactement sur la surface des faces, aucun des objets
n'est positionné au dessus/au dessous...
Solution 1 (voir code ci-joint) : décaler de `$\varepsilon=0.001$` chaque disque dans le bon sens.
Solution 2 (moins facile) : dessiner réellement chaque face comme le carré privé des disques
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+.001)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+.001)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par rebouxo :**
La source des scintillements viens que tu as des objets plans l'un sur l'autre. Il suffit de décaler les cercles légèrement du cube pour que le scintillement disparaisse, j'ai décalé de h.
Je propose ceci comme code
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
real h = 0.001 ;
surface cube = scale3(84*a)*unitcube ;
surface disqueX = scale3(9*a)*unitdisk ;
surface disqueY = rotate(90,Y)*scale3(9*a)*unitdisk ;
surface disqueZ = rotate(90,X)*scale3(9*a)*unitdisk ;
draw(cube, white, gray+linewidth(1bp));
surface[] face1 = {shift(42*a,42*a,84*(a+h))*disqueX} ;
surface[] face6 = {shift(14*a,14*a,-h)*disqueX,
shift(14*a,42*a,-h)*disqueX,
shift(14*a,70*a,-h)*disqueX,
shift(70*a,14*a,-h)*disqueX,
shift(70*a,42*a,-h)*disqueX,
shift(70*a,70*a,-h)*disqueX} ;
surface[] face2 = {shift(-h,14*a,14*a)*disqueY,
shift(-h,70*a,70*a)*disqueY} ;
surface[] face5 = {shift(84*(a+h),14*a,14*a)*disqueY,
shift(84*(a+h),14*a,70*a)*disqueY,
shift(84*(a+h),42*a,42*a)*disqueY,
shift(84*(a+h),70*a,14*a)*disqueY,
shift(84*(a+h),70*a,70*a)*disqueY} ;
surface[] face4 = {shift(14*a,84*(a+h),14*a)*disqueZ,
shift(14*a,84*(a+h),70*a)*disqueZ,
shift(70*a,84*(a+h),14*a)*disqueZ,
shift(70*a,84*(a+h),70*a)*disqueZ} ;
surface[] face3 = {shift(14*a,-h,14*a)*disqueZ,
shift(42*a,-h,42*a)*disqueZ,
shift(70*a,-h,70*a)*disqueZ} ;
surface[][] points = {face1,face2,face3,face4,face5,face6} ;
for(int i = 0 ; i < 6 ; ++i)
{
for(int cpt = 0 ; cpt <= i ; ++cpt)
{
draw(points[i][cpt],blue,blue) ;
}
}
La principale différence est d'utiliser systématiquement les objets 3d, plutôt que de gérer des objets plans, pour les plaquer sur le dés. Plutôt une histoire de goût, mais je soupçonne que ta méthode soit plus efficace, si il y a beaucoup d'objets. Comme je ne peux pas concaténer des surface (dommage) j'ai fait des tableaux de surface (un pour chaque face) et un tableau de ces tableaux, pour éviter des copier-coller.
Il manque des choses dans asymptote : faire des trous, des chanfreins, bref toutes choses utile pour la CAO.
|
|
4 |
|
|
Deux solutions ont données sur le forum [mathematex](http://forum.mathematex.net/asymptote-f34/supprimer-le-scintillement-d-un-de-a-jouer-en-3d-t16837.html) dédié à Asymptote par les modérateurs `OG` et `rebouxo`. Ils m'autorisent tous deux à les reproduire ici même.
**Première solution de OG :**
C'est normal (réponse facile). En effet les disques sont exactement sur la surface des faces, aucun des objets
n'est positionné au dessus/au dessous...
Solution 1 (voir code ci-joint) : décaler de `$\varepsilon=0.001$` chaque disque dans le bon sens.
Solution 2 (moins facile) : dessiner réellement chaque face comme le carré privé des disques
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+00.1)*X), tX=shift((84a+.001)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+0.01)*Z); tZ=shift((84a+.001)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par rebouxo :**
La source des scintillements viens que tu as des objets plans l'un sur l'autre. Il suffit de décaler les cercles légèrement du cube pour que le scintillement disparaisse, j'ai décalé de h.
Je propose ceci comme code
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
real h = 0.001 ;
surface cube = scale3(84*a)*unitcube ;
surface disqueX = scale3(9*a)*unitdisk ;
surface disqueY = rotate(90,Y)*scale3(9*a)*unitdisk ;
surface disqueZ = rotate(90,X)*scale3(9*a)*unitdisk ;
draw(cube, white, gray+linewidth(1bp));
surface[] face1 = {shift(42*a,42*a,84*(a+h))*disqueX} ;
surface[] face6 = {shift(14*a,14*a,-h)*disqueX,
shift(14*a,42*a,-h)*disqueX,
shift(14*a,70*a,-h)*disqueX,
shift(70*a,14*a,-h)*disqueX,
shift(70*a,42*a,-h)*disqueX,
shift(70*a,70*a,-h)*disqueX} ;
surface[] face2 = {shift(-h,14*a,14*a)*disqueY,
shift(-h,70*a,70*a)*disqueY} ;
surface[] face5 = {shift(84*(a+h),14*a,14*a)*disqueY,
shift(84*(a+h),14*a,70*a)*disqueY,
shift(84*(a+h),42*a,42*a)*disqueY,
shift(84*(a+h),70*a,14*a)*disqueY,
shift(84*(a+h),70*a,70*a)*disqueY} ;
surface[] face4 = {shift(14*a,84*(a+h),14*a)*disqueZ,
shift(14*a,84*(a+h),70*a)*disqueZ,
shift(70*a,84*(a+h),14*a)*disqueZ,
shift(70*a,84*(a+h),70*a)*disqueZ} ;
surface[] face3 = {shift(14*a,-h,14*a)*disqueZ,
shift(42*a,-h,42*a)*disqueZ,
shift(70*a,-h,70*a)*disqueZ} ;
surface[][] points = {face1,face2,face3,face4,face5,face6} ;
for(int i = 0 ; i < 6 ; ++i)
{
for(int cpt = 0 ; cpt <= i ; ++cpt)
{
draw(points[i][cpt],blue,blue) ;
}
}
La principale différence est d'utiliser systématiquement les objets 3d, plutôt que de gérer des objets plans, pour les plaquer sur le dés. Plutôt une histoire de goût, mais je soupçonne que ta méthode soit plus efficace, si il y a beaucoup d'objets. Comme je ne peux pas concaténer des surface (dommage) j'ai fait des tableaux de surface (un pour chaque face) et un tableau de ces tableaux, pour éviter des copier-coller.
Il manque des choses dans asymptote : faire des trous, des chanfreins, bref toutes choses utile pour la CAO.
|
|
3 |
Amélioration du style
|
|
Deux solutions ont données sur le forum [mathematex](http://forum.mathematex.net/asymptote-f34/supprimer-le-scintillement-d-un-de-a-jouer-en-3d-t16837.html) dédié à Asymptote par les modérateurs OG `OG` et rebouxo. `rebouxo`. Ils m'autorisent tous deux à les reproduire ici même.
**Première solution de OG :**
C'est normal (réponse facile). En effet les disques sont exactement sur la surface des faces, aucun des objets
n'est positionné au dessus/au dessous...
Solution 1 (voir code ci-joint) : décaler de `$\varepsilon=0.001$` chaque disque dans le bon sens.
Solution 2 (moins facile) : dessiner réellement chaque face comme le carré privé des disques
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+00.1)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+0.01)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par rebouxo :**
La source des scintillements viens que tu as des objets plans l'un sur l'autre. Il suffit de décaler les cercles légèrement du cube pour que le scintillement disparaisse, j'ai décalé de h.
Je propose ceci comme code
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
real h = 0.001 ;
surface cube = scale3(84*a)*unitcube ;
surface disqueX = scale3(9*a)*unitdisk ;
surface disqueY = rotate(90,Y)*scale3(9*a)*unitdisk ;
surface disqueZ = rotate(90,X)*scale3(9*a)*unitdisk ;
draw(cube, white, gray+linewidth(1bp));
surface[] face1 = {shift(42*a,42*a,84*(a+h))*disqueX} ;
surface[] face6 = {shift(14*a,14*a,-h)*disqueX,
shift(14*a,42*a,-h)*disqueX,
shift(14*a,70*a,-h)*disqueX,
shift(70*a,14*a,-h)*disqueX,
shift(70*a,42*a,-h)*disqueX,
shift(70*a,70*a,-h)*disqueX} ;
surface[] face2 = {shift(-h,14*a,14*a)*disqueY,
shift(-h,70*a,70*a)*disqueY} ;
surface[] face5 = {shift(84*(a+h),14*a,14*a)*disqueY,
shift(84*(a+h),14*a,70*a)*disqueY,
shift(84*(a+h),42*a,42*a)*disqueY,
shift(84*(a+h),70*a,14*a)*disqueY,
shift(84*(a+h),70*a,70*a)*disqueY} ;
surface[] face4 = {shift(14*a,84*(a+h),14*a)*disqueZ,
shift(14*a,84*(a+h),70*a)*disqueZ,
shift(70*a,84*(a+h),14*a)*disqueZ,
shift(70*a,84*(a+h),70*a)*disqueZ} ;
surface[] face3 = {shift(14*a,-h,14*a)*disqueZ,
shift(42*a,-h,42*a)*disqueZ,
shift(70*a,-h,70*a)*disqueZ} ;
surface[][] points = {face1,face2,face3,face4,face5,face6} ;
for(int i = 0 ; i < 6 ; ++i)
{
for(int cpt = 0 ; cpt <= i ; ++cpt)
{
draw(points[i][cpt],blue,blue) ;
}
}
La principale différence est d'utiliser systématiquement les objets 3d, plutôt que de gérer des objets plans, pour les plaquer sur le dés. Plutôt une histoire de goût, mais je soupçonne que ta méthode soit plus efficace, si il y a beaucoup d'objets. Comme je ne peux pas concaténer des surface (dommage) j'ai fait des tableaux de surface (un pour chaque face) et un tableau de ces tableaux, pour éviter des copier-coller.
Il manque des choses dans asymptote : faire des trous, des chanfreins, bref toutes choses utile pour la CAO.
|
|
2 |
Amélioration du style
|
|
Deux solutions ont données sur le forum [mathematex](http://forum.mathematex.net/asymptote-f34/supprimer-le-scintillement-d-un-de-a-jouer-en-3d-t16837.html) dédié à Asymptote par les modérateurs OG et rebouxo. Ils m'autorisent tous deux à les reproduire ici même.
**Première solution de OG :**
C'est normal (réponse facile). En effet les disques sont exactement sur la surface des faces, aucun des objets
n'est positionné au dessus/au dessous...
Solution 1 (voir code ci-joint) : décaler de $\varepsilon=0.001$ `$\varepsilon=0.001$` chaque disque dans le bon sens.
Solution 2 (moins facile) : dessiner réellement chaque face comme le carré privé des disques
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+00.1)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+0.01)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par rebouxo :**
La source des scintillements viens que tu as des objets plans l'un sur l'autre. Il suffit de décaler les cercles légèrement du cube pour que le scintillement disparaisse, j'ai décalé de h.
Je propose ceci comme code
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
real h = 0.001 ;
surface cube = scale3(84*a)*unitcube ;
surface disqueX = scale3(9*a)*unitdisk ;
surface disqueY = rotate(90,Y)*scale3(9*a)*unitdisk ;
surface disqueZ = rotate(90,X)*scale3(9*a)*unitdisk ;
draw(cube, white, gray+linewidth(1bp));
surface[] face1 = {shift(42*a,42*a,84*(a+h))*disqueX} ;
surface[] face6 = {shift(14*a,14*a,-h)*disqueX,
shift(14*a,42*a,-h)*disqueX,
shift(14*a,70*a,-h)*disqueX,
shift(70*a,14*a,-h)*disqueX,
shift(70*a,42*a,-h)*disqueX,
shift(70*a,70*a,-h)*disqueX} ;
surface[] face2 = {shift(-h,14*a,14*a)*disqueY,
shift(-h,70*a,70*a)*disqueY} ;
surface[] face5 = {shift(84*(a+h),14*a,14*a)*disqueY,
shift(84*(a+h),14*a,70*a)*disqueY,
shift(84*(a+h),42*a,42*a)*disqueY,
shift(84*(a+h),70*a,14*a)*disqueY,
shift(84*(a+h),70*a,70*a)*disqueY} ;
surface[] face4 = {shift(14*a,84*(a+h),14*a)*disqueZ,
shift(14*a,84*(a+h),70*a)*disqueZ,
shift(70*a,84*(a+h),14*a)*disqueZ,
shift(70*a,84*(a+h),70*a)*disqueZ} ;
surface[] face3 = {shift(14*a,-h,14*a)*disqueZ,
shift(42*a,-h,42*a)*disqueZ,
shift(70*a,-h,70*a)*disqueZ} ;
surface[][] points = {face1,face2,face3,face4,face5,face6} ;
for(int i = 0 ; i < 6 ; ++i)
{
for(int cpt = 0 ; cpt <= i ; ++cpt)
{
draw(points[i][cpt],blue,blue) ;
}
}
La principale différence est d'utiliser systématiquement les objets 3d, plutôt que de gérer des objets plans, pour les plaquer sur le dés. Plutôt une histoire de goût, mais je soupçonne que ta méthode soit plus efficace, si il y a beaucoup d'objets. Comme je ne peux pas concaténer des surface (dommage) j'ai fait des tableaux de surface (un pour chaque face) et un tableau de ces tableaux, pour éviter des copier-coller.
Il manque des choses dans asymptote : faire des trous, des chanfreins, bref toutes choses utile pour la CAO.
|
|
1 |
|
|
Deux solutions ont données sur le forum [mathematex](http://forum.mathematex.net/asymptote-f34/supprimer-le-scintillement-d-un-de-a-jouer-en-3d-t16837.html) dédié à Asymptote par les modérateurs OG et rebouxo. Ils m'autorisent tous deux à les reproduire ici même.
**Première solution de OG :**
C'est normal (réponse facile). En effet les disques sont exactement sur la surface des faces, aucun des objets
n'est positionné au dessus/au dessous...
Solution 1 (voir code ci-joint) : décaler de $\varepsilon=0.001$ chaque disque dans le bon sens.
Solution 2 (moins facile) : dessiner réellement chaque face comme le carré privé des disques
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
path carre = box ((0,0),(84a,84a)),
disque = scale(9a)*unitcircle,
patron1[] = shift(42a,42a)*disque,
patron2[] = shift(14a,70a)*disque^^shift(70a,14a)*disque,
patron3[] = shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(42a,42a)*disque,
patron4[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque,
patron5[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,42a)*disque,
patron6[] = shift(14a,14a)*disque^^shift(14a,70a)*disque^^shift(70a,14a)*disque^^shift(70a,70a)*disque^^shift(42a,70a)*disque^^shift(42a,14a)*disque;
transform3 tX=shift((84a+00.1)*X), tY=shift((84a+.001)*Y), tZ=shift((84a+0.01)*Z);
path3 facegauche[] =shift(0,-0.001,0)*path3(patron6,ZXplane),
facedroite[] =path3(patron1,ZXplane),
faceavant[] =path3(patron2,YZplane),
facearriere[] =shift(-0.001,0,0)*path3(patron5,YZplane),
facehaut[] =path3(patron4,XYplane),
facebas[] =shift(0,0,-0.001)*path3(patron3,XYplane);
draw(scale3(84a)*unitcube, surfacepen=white);
draw(box(O, 84a*(X+Y+Z)), gray);
draw(surface(facegauche),blue);
draw(surface(tY*facedroite),blue);
draw(surface(tZ*facehaut),blue);
draw(surface(facebas),blue);
draw(surface(facearriere),blue);
draw(surface(tX*faceavant),blue);
**Deuxième solution par rebouxo :**
La source des scintillements viens que tu as des objets plans l'un sur l'autre. Il suffit de décaler les cercles légèrement du cube pour que le scintillement disparaisse, j'ai décalé de h.
Je propose ceci comme code
import three;
currentprojection =orthographic((5,2,3));
currentlight=nolight;
settings.tex="latex"; // Moteur LaTeX utilisé pour la compilation (latex, pdflatex, ...)
settings.outformat="pdf"; // Format de sortie ; eps par défaut
settings.prc=true; // Format PRC de la figure ; vrai par défaut
settings.render=-1; // Rendu des figures ; -1 par défaut
size(6cm,0);
real a = 0.05;
real h = 0.001 ;
surface cube = scale3(84*a)*unitcube ;
surface disqueX = scale3(9*a)*unitdisk ;
surface disqueY = rotate(90,Y)*scale3(9*a)*unitdisk ;
surface disqueZ = rotate(90,X)*scale3(9*a)*unitdisk ;
draw(cube, white, gray+linewidth(1bp));
surface[] face1 = {shift(42*a,42*a,84*(a+h))*disqueX} ;
surface[] face6 = {shift(14*a,14*a,-h)*disqueX,
shift(14*a,42*a,-h)*disqueX,
shift(14*a,70*a,-h)*disqueX,
shift(70*a,14*a,-h)*disqueX,
shift(70*a,42*a,-h)*disqueX,
shift(70*a,70*a,-h)*disqueX} ;
surface[] face2 = {shift(-h,14*a,14*a)*disqueY,
shift(-h,70*a,70*a)*disqueY} ;
surface[] face5 = {shift(84*(a+h),14*a,14*a)*disqueY,
shift(84*(a+h),14*a,70*a)*disqueY,
shift(84*(a+h),42*a,42*a)*disqueY,
shift(84*(a+h),70*a,14*a)*disqueY,
shift(84*(a+h),70*a,70*a)*disqueY} ;
surface[] face4 = {shift(14*a,84*(a+h),14*a)*disqueZ,
shift(14*a,84*(a+h),70*a)*disqueZ,
shift(70*a,84*(a+h),14*a)*disqueZ,
shift(70*a,84*(a+h),70*a)*disqueZ} ;
surface[] face3 = {shift(14*a,-h,14*a)*disqueZ,
shift(42*a,-h,42*a)*disqueZ,
shift(70*a,-h,70*a)*disqueZ} ;
surface[][] points = {face1,face2,face3,face4,face5,face6} ;
for(int i = 0 ; i < 6 ; ++i)
{
for(int cpt = 0 ; cpt <= i ; ++cpt)
{
draw(points[i][cpt],blue,blue) ;
}
}
La principale différence est d'utiliser systématiquement les objets 3d, plutôt que de gérer des objets plans, pour les plaquer sur le dés. Plutôt une histoire de goût, mais je soupçonne que ta méthode soit plus efficace, si il y a beaucoup d'objets. Comme je ne peux pas concaténer des surface (dommage) j'ai fait des tableaux de surface (un pour chaque face) et un tableau de ces tableaux, pour éviter des copier-coller.
Il manque des choses dans asymptote : faire des trous, des chanfreins, bref toutes choses utile pour la CAO.
