Intersection de deux plans

[XavteX]

Bonjour,

Avec three, il existe la commande "intersectionpoints" pour l'intersection entre une ligne et une surface.
Et pour deux plans?

Merci

[maurice]

Bonjour,

Bonjour,

Avec three,
Il existe la commande "intersectionpoints" pour l'intersection entre une ligne et une surface.
Et pour deux plans?

Merci

Je ne connais rien de tel. Je ne crois pas qu'asymptote gère l'intersection de 2 surfaces.
Je te renvoie quand même à la galerie de Gaétan pour un exemple

Maurice

[XavteX]

Merci Maurice
Je vais me débrouiller autrement...
Pourquoi utilises tu "Embedded"?

[maurice]

Merci Maurice
Pourquoi utilises tu "Embedded"?

C'est juste parce que tu semblais vouloir écrire sur le plan que je l'ai utilisé. Sinon je ne l'utilise que très rarement.

J'avais découvert son existence avec ce sujet

Maurice

[Romain Janvier]

Perso, je triche pour faire cela et je cherche l'intersection entre des droites de chacun des plans pour trouver 2 points me servant à tracer l'intersection. Mais il faut bien choisir ses droites.

[chellier]

Perso, je triche pour faire cela et je cherche l'intersection entre des droites de chacun des plans pour trouver 2 points me servant à tracer l'intersection. Mais il faut bien choisir ses droites.

On peut essayer d'automatiser un peu ça :

intersection3.png (38.2 Kio) Consulté 3272 fois

Code : Tout sélectionner

size(7.5cm,0);
import three;
currentprojection=obliqueX;
currentlight=nolight;

path3 interplane(path3 plan1, path3 plan2) {
  path3 ligne1=point(plan1,0)--point(plan1,1), ligne2=point(plan1,2)--point(plan1,3);
  triple[] int1=intersectionpoints(ligne1,surface(plan2));
  triple[] int2=intersectionpoints(ligne2,surface(plan2));
  return int1[0]--int2[0];
}

triple v1=(4,0,0), v2=(0,6,0), v3=.5*v2;

path3 pl1=plane(v1,v2,O);
path3 pl2=shift(.5Z)*rotate(45,Y)*pl1;
path3 pl3=shift(-2Z+2Y)*rotate(-10,Z)*plane(v1,v3,O);;

draw(surface(pl1),paleblue);
draw(surface(pl2),gray+opacity(.8),black);
draw(surface(pl3),paleblue);

draw(interplane(pl1,pl2),.8bp+red);
draw(interplane(pl3,pl2),.8bp+heavygreen);

Christophe

[Romain Janvier]

Super !
Par contre, cela manque d'un test au cas où il n'y a pas d'intersection entre les deux plans, où du moins entre les quadrilatères qui les représentent.

[chellier]

Oui, c'est vrai, il faudrait pas mal de tests en plus. Avis aux amateurs :D
À noter que je n'ai pas bien choisi le nom pour plan2, puisqu'il suffit que ce soit une surface plane :

interSurf.png (46.53 Kio) Consulté 3263 fois

Code : Tout sélectionner

size(7.5cm,0);
import three;
settings.prc=false;
settings.render=4;
currentprojection=obliqueX;
currentlight=nolight;

path3 interplane(path3 plan1, path3 plan2) {
  path3 ligne1=point(plan1,0)--point(plan1,1), ligne2=point(plan1,2)--point(plan1,3);
  triple[] int1=intersectionpoints(ligne1,surface(plan2));
  triple[] int2=intersectionpoints(ligne2,surface(plan2));
  return int1[0]--int2[0];
}

triple v1=(4,0,0), v2=(0,3,0);

path3 pl1=plane(v1,v2,(-2,-1.5,0));
path3 c=circle(O,2,X+Z);

draw(surface(pl1),paleblue);
draw(surface(c),gray+opacity(.8),black);

draw(interplane(pl1,c),.8bp+red);

Christophe

[chellier]

Quelques améliorations
J'ai ajouté des tests pour que la figure soit quand même construite même s'il n'y a pas d'intersection avec les côtés du polygone représentant le plan.
Le plan peut être représenté par n'importe quel polygone.

À noter : on peut aussi utiliser bsp, mais on perd la 3D :( (voir ici)

Code : Tout sélectionner

size(7.5cm,0);
import three;
settings.render=4;
currentprojection=obliqueX;
currentlight=nolight;

path3 interplane(path3 plan1, path3 surfplane) {
  path3[] ligne;
  triple[][] iter;
  triple[] pinter; 
  int n=size(plan1);
  for (int i=0; i<n; ++i) {
    ligne[i]=point(plan1,i)--point(plan1,(i+1)%n);
    iter[i]=intersectionpoints(ligne[i],surface(surfplane));
    if(iter[i].length==1) pinter.push(iter[i][0]);}

  if(pinter.length==0){
    warning("interplane","pas de point d'intersection");
    return nullpath3;}
  else if(pinter.length==1){
    warning("interplane","un seul point d'intersection");
    return nullpath3;}
  else return pinter[0]--pinter[1];
}

triple v1=(0,4,0), v2=(0,0,5), v3=.5*v1, v4=(-2,0,0);

path3 pl1=plane(v1,v2,-2.5Z);
path3 pl2=plane(v3,v4,X+Y);
path3 pl3=shift(-1.5*Z)*rotate(-25,Z)*pl2;
path3 tri=(1,2,1.5)--(-1,1,1.5)--(-1,3,1.5)--cycle;

draw(surface(pl1),gray+opacity(.8),black);
draw(surface(pl2),paleblue);
draw(surface(pl3),paleblue);
draw(surface(tri),paleblue);

if(interplane(pl2,pl1) != nullpath3) draw(interplane(pl2,pl1),.8bp+red);
if(interplane(pl3,pl1) != nullpath3) draw(interplane(pl3,pl1),.8bp+heavyblue);
if(interplane(tri,pl1) != nullpath3) draw(interplane(tri,pl1),.8bp+heavymagenta);

intercube.png (89.29 Kio) Consulté 3245 fois

Code : Tout sélectionner

size(7.5cm,0);
import three;
settings.render=4;
currentlight=nolight;

path3 interplane(path3 plan1, path3 surfplane) {
  path3[] ligne;
  triple[][] iter;
  triple[] pinter; 
  int n=size(plan1);
  for (int i=0; i<n; ++i) {
    ligne[i]=point(plan1,i)--point(plan1,(i+1)%n);
    iter[i]=intersectionpoints(ligne[i],surface(surfplane));
    if(iter[i].length==1) pinter.push(iter[i][0]);}

  if(pinter.length==0){
    warning("interplane","pas de point d'intersection");
    return nullpath3;}
  else if(pinter.length==1){
    warning("interplane","un seul point d'intersection");
    return nullpath3;}
  else return pinter[0]--pinter[1];
}

triple A=(1,0,0), B=(1,1,0), C=(0,1,0), D=(1,0,1),
       pE=(1,1,1), F=(0,1,1), G=(0,0,1);

path3[] cube;
cube[0]=O--A--B--C--cycle;
cube[1]=O--A--D--G--cycle;
cube[2]=O--C--F--G--cycle;
cube[3]=pE--D--A--B--cycle;
cube[4]=pE--F--C--B--cycle;
cube[5]=pE--F--G--D--cycle;

triple v1=(2,0,0), v2=(0,2,0);
path3 plan=shift(-.1*X-.8*Y+.5*Z)*rotate(45,X+Y+Z)*plane(v1,v2);
draw(surface(plan),paleblue);

for (int i=0; i<6; ++i){
  draw(surface(cube[i]),gray+opacity(.8),bp+black);
  if(interplane(cube[i],plan) != nullpath3) draw(interplane(cube[i],plan),.8bp+red);}

Code : Tout sélectionner

size(7.5cm,0);
import three;
settings.render=4;
currentlight=nolight;

path3 interplane(path3 plan1, path3 surfplane) {
  path3[] ligne;
  triple[][] iter;
  triple[] pinter; 
  int n=size(plan1);
  for (int i=0; i<n; ++i) {
    ligne[i]=point(plan1,i)--point(plan1,(i+1)%n);
    iter[i]=intersectionpoints(ligne[i],surface(surfplane));
    if(iter[i].length==1) pinter.push(iter[i][0]);}

  if(pinter.length==0){
    warning("interplane","pas de point d'intersection");
    return nullpath3;}
  else if(pinter.length==1){
    warning("interplane","un seul point d'intersection");
    return nullpath3;}
  else return pinter[0]--pinter[1];
}

triple A=(1,0,0), B=(0,1,0), pS=(0,0,2);

path3[] pyramide;
pyramide[0]=O--A--B--cycle;
pyramide[1]=O--A--pS--cycle;
pyramide[2]=O--B--pS--cycle;
pyramide[3]=pS--A--B--cycle;

triple v1=(2,0,0), v2=(0,2,0);
path3 plan=shift(-.1*X-.8*Y+.5*Z)*rotate(45,X+Y+Z)*plane(v1,v2);
draw(surface(plan),paleblue);

for (int i=0; i<4; ++i){
  draw(surface(pyramide[i]),gray+opacity(.8),bp+black);
  if(interplane(pyramide[i],plan) != nullpath3) draw(interplane(pyramide[i],plan),.8bp+red);}

interplane est compatible avec polyhedron_js.asy :

interpolyhedron.png (110.36 Kio) Consulté 3245 fois

Code : Tout sélectionner

import polyhedron_js;
settings.render=4;
size(7.5cm,0);
currentlight=nolight;

path3 interplane(path3 plan1, path3 surfplane) {
  path3[] ligne;
  triple[][] iter;
  triple[] pinter; 
  int n=size(plan1);
  for (int i=0; i<n; ++i) {
    ligne[i]=point(plan1,i)--point(plan1,(i+1)%n);
    iter[i]=intersectionpoints(ligne[i],surface(surfplane));
    if(iter[i].length==1) pinter.push(iter[i][0]);}

  if(pinter.length==0){
    warning("interplane","pas de point d'intersection");
    return nullpath3;}
  else if(pinter.length==1){
    warning("interplane","un seul point d'intersection");
    return nullpath3;}
  else return pinter[0]--pinter[1];
}

polyhedron[] parr={dodecahedron};
filldraw(parr,new pen[]{gray},op=0.8);

triple v1=(2,0,0), v2=(0,2,0);
path3 plan=shift(-.1*X-1.5*Y+.1*Z)*rotate(45,X+Y+Z)*plane(v1,v2);
draw(surface(plan),paleblue);

for (int i=0; i<12; ++i){
  if(interplane(dodecahedron[i],plan) != nullpath3) draw(interplane(dodecahedron[i],plan),.8bp+red);}

Christophe

[chellier]

Une petite mise à jour d'interplane, il n'y a plus besoin de préciser le nombre de côtés du plan (j'ai édité mon message précédent) :

Code : Tout sélectionner

size(7.5cm,0);
import three;
settings.render=4;
currentlight=nolight;

path3 interplane(path3 plan1, path3 surfplane) {
  path3[] ligne;
  triple[][] iter;
  triple[] pinter; 
  int n=size(plan1);
  for (int i=0; i<n; ++i) {
    ligne[i]=point(plan1,i)--point(plan1,(i+1)%n);
    iter[i]=intersectionpoints(ligne[i],surface(surfplane));
    if(iter[i].length==1) pinter.push(iter[i][0]);}
  if(pinter.length==0){
    warning("interplane","pas de point d'intersection");
    return nullpath3;}
  else if(pinter.length==1){
    warning("interplane","un seul point d'intersection");
    return nullpath3;}
  else return pinter[0]--pinter[1];
}

triple A=(1,0,0), B=(1.5,1.5,0), C=(0,1,0), pS=(0,0,2);
path3[] pyramide;
pyramide[0]=O--A--B--C--cycle;
pyramide[1]=O--A--pS--cycle;
pyramide[2]=O--C--pS--cycle;
pyramide[3]=pS--A--B--cycle;
pyramide[4]=pS--B--C--cycle;
triple v1=(2,0,0), v2=(0,0.8,1.5);
path3 plan=plane(v1,v2,(-.5,.5,-.5));
draw(surface(plan),paleblue);

for (int i=0; i<5; ++i){
  draw(surface(pyramide[i]),gray+opacity(.8),bp+black);
  if(interplane(pyramide[i],plan) != nullpath3) draw(interplane(pyramide[i],plan),.8bp+red);
}

Il reste quelques cas limites qu'il faudrait étudier comme par exemple si un côté du plan est inclus dans la surface. Il faudrait pouvoir tester si un point est sur une surface, mais je ne vois pas comment faire :( Une idée

Christophe

[chellier]

Bon eh bien j'ai continué à m'amuser tout seul avec ces intersections de plan . Je n'ai pas testé tous les cas possibles, mais ça a l'air de fonctionner à peu près.

Les routines à mettre dans un fichier myplane.asy ou macros3D.asy à mettre dans le même répertoire que la figure ou dans le répertoire .asy du répertoire personnel :

Code : Tout sélectionner

import three;

bool inplan(triple p, path3 surfplane) {
  triple n=normal(surfplane);
  triple[] int=intersectionpoints(p--shift(n)*p,surface(surfplane));
  return (int.length!=0 && abs(int[0]-p)<.0001);
}

path3 interplane(path3 plan1, path3 surfplane) {
  path3 intersec;
  path3[] ligne;
  triple[][] iter;
  triple[] pinter; 
  int n=size(plan1);
  for (int i=0; i<n; ++i) {
    ligne[i]=point(plan1,i)--point(plan1,(i+1)%n);
    if(inplan(point(plan1,i),surfplane) && inplan(point(plan1,(i+1)%n),surfplane)) {
      intersec=intersec & ligne[i];}
    else {
      iter[i]=intersectionpoints(ligne[i],surface(surfplane));
      if(iter[i].length==1) pinter.push(iter[i][0]);}}

  if(pinter.length==0 && intersec==nullpath3){
    warning("interplane","pas de point d'intersection");
    intersec=nullpath3;}
  else if(pinter.length==1 && intersec==nullpath3){
    warning("interplane","un seul point d'intersection");
    intersec=nullpath3;}
  else if(pinter.length>=2 && abs(pinter[0]-pinter[1])>=.0001 && intersec==nullpath3) intersec=pinter[0]--pinter[1];
  else if(pinter.length>2 && abs(pinter[0]-pinter[1])<.0001 && intersec==nullpath3) intersec=pinter[0]--pinter[2];
  return intersec;
}

Le code suivant compilé par asy -noV

Code : Tout sélectionner

size(12cm,0);
import myplane;
import animation;
//settings.tex="pdflatex";
settings.outformat="gif";
settings.render=4;
settings.prc=false;
currentlight=nolight;

triple A=(1,0,0), B=(1,2,0), C=(0,2,0), D=(1,0,1.5),
       pE=(1,2,1.5), F=(0,2,1.5), G=(0,0,1.5);

path3[] pave;
pave[0]=O--A--B--C--cycle;
pave[1]=O--A--D--G--cycle;
pave[2]=O--C--F--G--cycle;
pave[3]=pE--D--A--B--cycle;
pave[4]=pE--F--C--B--cycle;
pave[5]=pE--F--G--D--cycle;

animation Anim;
triple v1=1.5*(A-O), v2=2*(D-A);
// --- pour fixer les dimensions de la figure ---
draw(-2*Y--3.5*Y,invisible);
draw(-1.5*Z--3.5*Z,invisible);
// ----------------------------------------------
for (int i=0; i<6; ++i){
  draw(surface(pave[i]),gray+opacity(.8),1.5bp+black);
}
Anim.add();

for (int ang=0; ang<91; ang+=5) {
save();
transform3 t=rotate(-ang,X);
path3 plan=plane(v1,t*v2,O-.25*X);
draw(surface(plan),paleblue);
for (int i=0; i<6; ++i){
  if(interplane(pave[i],plan) != nullpath3) draw(interplane(pave[i],plan),2bp+red); 
}
Anim.add();
restore();
}
erase();
Anim.movie(loops=50,delay=250);

donnera le gif suivant :

interplaneV2.gif (44.23 Kio) Consulté 3217 fois

Ça me permettra au moins de refaire mon cours sur les sections planes

Christophe

[Romain Janvier]

Bravo, c'est mortel ton truc. Il va falloir que je me penche là dessus.

[chellier]

Merci !

De plus, si on prend les points dans le "bon" sens, on peut récupérer l'intersection sous forme de chemin cyclique, ce qui permet de la colorer par exemple :

Code : Tout sélectionner

size(7.5cm,0);
import myplane;
settings.render=4;
currentlight=nolight;

triple A=(1,0,0), B=(1.5,1,0), C=(1,1.5,0), D=(0,1,0), pS=(0,0,2),pE=(-.5,.5,0);

path3[] pyramide;
pyramide[0]=O--pE--D--C--B--A--cycle;
pyramide[1]=pS--O--A--cycle;
pyramide[2]=pS--A--B--cycle;
pyramide[3]=pS--B--C--cycle;
pyramide[4]=pS--C--D--cycle;
pyramide[5]=pS--D--pE--cycle;
pyramide[6]=pS--pE--O--cycle;

triple v1=(2,0,0), v2=(0,0.8,1.5);
path3 plan=plane(v1,v2,(-.5,.5,-.5));
path3 moninter;

for (int i=0; i<7; ++i){
  draw(surface(pyramide[i]),gray+opacity(.8));
  draw(pyramide[i],bp+black);
  if(interplane(pyramide[i],plan) != nullpath3) {
    moninter=moninter & interplane(pyramide[i],plan);    
  }
}
moninter=moninter--cycle;
draw(moninter,.8bp+red);
draw(surface(reverse(moninter)^^plan,planar=true),paleblue);
draw(surface(moninter),yellow);

Christophe

[maurice]

Bon eh bien j'ai continué à m'amuser tout seul avec ces intersections de plan . Je n'ai pas testé tous les cas possibles, mais ça a l'air de fonctionner à peu près.

bravo Christophe, ça à l'air pas mal du tout, on va tester ça ....!

Maurice

[Francky]

Géant, j'arrive un peu tard, mais c'est terrible.

[pluton]

Bon, pensez-vous que ces figures puissent être exportées dans un format purement vectoriel ?

[OG]

Bon, pensez-vous que ces figures puissent être exportées dans un format purement vectoriel ?

Non. C'est soit en PRC, soit en OpenGL.
Ou alors pour des figures simples, tu implémentes la chose avec render=0 et le module bsp (binary space partition).

O.G.

[pluton]

en fait, j'ai fait une petite tentative hier soir et je me demande dans quelle mesure
on ne pourrait pas exporter en vectoriel à partir du PRC : je ne connais pas vraiment
les spécifications du format mais on dirait que c'est faisable. C'est peut-être une vue
de l'esprit.

[OG]

Le format PRC est décrit par Adobe. Mes très faibles connaissances du format
me font dire que c'est une description de scène (lumière, objet décrit avec des NURBS).
Cela est très intéressant mais nurbs and Cie n'est pas mon domaine.

O.G.