On a présenté les premiers régionnements du plan pour l’orthogonalité de la géométrie non arguésienne dans le modèle de Hilbert dans ces pages du menu Non Arg :
• Introduction et parties 2H et 2H1E : deux perp. hilbertiennes (2H) et une euclidienne (2H1E)
• La partie 1H1E : une seule perpendiculaire hilbertienne et une euclidienne.
Dans cet article on présente l’organisation de la mise en œuvre de la partie 1H1E, la partie jaune de la page ci-dessus.
Notations et premières variables
La région 1H1E est généralement composées de 4 parties, deux issues des intersections de la droite \((AB)\) avec l’ellipse, soit les points \(Ph\) et\(Qb\) et deux autres issues des points \(QbPo, PhQo\) ou \(PhQb\), ces parties pouvant parfois être en dehors de l’écran, ou tout simplement ne pas exister.
Les limites à l’écran des droites sont matérialisées par les points \(Ph2G, Ph2D\), puis \(PhoG, PhoD\) pour les deux droites passant par \(Ph\), et \(Qb2G, Qb2D, QboG, QboD\) pour les deux droites passant par \(Qb\). Si, bien entendu les suffixes \(G\) et \(D\) indiquent la position relative gauche/droite des points, ils ne renseignement pas sur la position haut/bas. Il y aura donc systématiquement un traitement à faire pour distinguer ces deux cas.
Le point \(PhQo\) est l’intersection des deux droites affines \((Ph \, Ph_2)\) et \((Qb \, Qbo)\), \(QbPo\), celle des droites affines \((Qb \, Qb_2)\) et \((Ph \, Pho)\). Enfin le point \(PhQb\), celle des droites affines \((Ph \, Ph_2)\) et \((Qb \, Qb_2)\). Les coins de l’écran sont nommés \(HG, BG, HD, BD\).
Comme dans de nombreux autres articles de ce site, en particulier les remplissages de polygones hyperboliques, les différentes parties sont construite par des listes de segments. On note Prep1H1Ep1, et Prep1H1Ep2 les listes issues des points \(Ph\) et \(Qb\) respectivement, puis Prep1H1Ep3 et Prep1H1Ep4 les deux autres parties – ci-dessus issues de \(QbPo\) et \(PhQo\), mais qui peuvent être issues aussi de \(PhQb\).
Les parties Prep1H1Ep3 et Prep1H1Ep4
Elles sont élémentaires à construire. On teste d’abord la présence des points \(PhQo, QbPo\) et \(PhQb\) à l’écran, à partir de leurs coordonnées et de celles de l’écran. On introduit ainsi trois booléens comme celui-ci :
PhQoEcran=((PhQo[0]<xMax)&&(PhQo[0]>xMin))&&((PhQo[1]<yMax)&&(PhQo[1]>yMin))
Prep1H1Ep3 sera toujours de sommet \(QbPo\), par contre Prep1H1Ep4 peut être de sommet \(PhQo\) ou \(PhQb\).
Ci-dessus une configuration assez générique, ci-dessous, une autre plus spécifique
Code utilisé
On rappelle que dans les expressions JavaScript de DGPad, il est préférable d’utiliser la notation M[0] plutôt que x(M) pour l’abscisse du point M ,et M[1] pour son ordonnée..
var tab=[];var Prep1H1Ep3=[];var Prep1H1Ep4=[];if ((PhQoEcran==1)&&(PhQo[0]>PhQb[0])) {var Prep1H1Ep4=[PhQo,Ph2D,(QboD[1]<0)?BD:HD,QboD,PhQo]};if ((QbPoEcran==1)&&(QbPo[0]>PhQb[0])) {var Prep1H1Ep3=[QbPo,PhoD,(Qb2D[1]<0)?BD:HD,Qb2D,QbPo]} else {if ((PhQbEcran==1)&&(PhQo[0]<PhQb[0])){var Prep1H1Ep4=[PhQb,Ph2D,(abs(Ph2D[1]-yMin)<0.001==1)?BD:HD,Qb2D,PhQb]}};var LGene=Prep1H1Ep3; var n=(LGene).length;if (n>1) {for (var i=0;i<n;i++){var k= LGene[i];tab.push(k)};tab.push(LGene[0]);tab.push([NaN,NaN]);};var LGene=Prep1H1Ep4; var n=(LGene).length;if (n>1) {for (var i=0;i<n;i++){var k= LGene[i];tab.push(k)};tab.push(LGene[0]);};tab
Le (abs(Ph2D[1]-yMin)<0.001==1) conservé ici est probablement une précaution inutile, mise en place ici car JavaScript ne traite pas l’égalité de réels. La fin de l’expression transforme les différentes parties en une seule liste. Cette partie aura plus de sens quand on ajoutera les deux premières parties, structurées autrement.
Manipulation de cette première partie
Préférer ouvrir cette figure, plus large, dans un nouvel onglet.
Les parties issues de Ph et Qb
Elles peuvent comporter un arc de cercle, ou deux – et même parfois trois, et se terminent par un triangle ou un quadrilatère selon la configuration à l’écran. On construit donc en préalable les 4 listes que l’on voit dans la première illustration, arbitrairement composées de 20 segments (et donc 21 points) réalisées par une macro construction. Il faut donc :
• Tout d’abord caractériser quand la partie comprend un arc, deux, ou trois,
• Sinon c’est un quadrilatère (un triangle, parfois même un pentagone) issu de \(Ph\) (Prep1H1Ep1) ou de \(Qb\) (Prep1H1Ep2). On rappelle que \(Ph\) est celui des deux points d’intersection de \((AB)\) avec l’ellipse qui a la plus grande ordonnée. Il en résulte que le traitement du quadrilatère sera différent pour les deux parties. Ce sont les listes LeQDPh et LeQDQb.
• Dans le cas de la présence d’arcs, on construit, séparément, la finalisation quadrilatère-triangle dans des listes présentes à l’écran, que l’on nomme, pour le point \(Ph\), respectivement LeQD2Pho qui convient pour finaliser les parties à un ou deux arcs, et FinPh3arcs pour le cas des trois arcs comme ci-dessous.
Exemple de la partie issue de \(Ph\), avec trois arcs de cercles et la liste FinPh3arcs
La caractérisation de la partie à 3 arcs est élémentaire, c’est la présence de \(QbPo\) à l’intérieur de l’ellipse. Quand on manipule la figure, c’est une évidence. La partie du code correspondante s’écrit alors
if (QbPoInHell==1) {var Prep1H1Ep1=[ListeQb2Inter,ListeInterPh,ListePhPh2,FinPh3arcs];}
On note que Prep1H1Ep1, mais aussi Prep1H1Ep2 sont des listes de listes qu’il faudra aplatir pour les tracer.
Le cas d’un seul arc issu de \(Ph\)
C’est nécessairement l’arc \(Ph \, Pho\). La caractérisation semble à priori élémentaire, il suffit que \(Ph\) soit entre \(Pho\) et \(Ph2\) comme ci-dessous :
(Ph[0]-Pho[0])*(Ph[0]-Ph2[0])<0 comme caractérisation des configurations ayant un seul arc de cercle ?
Mais ce n’est pas aussi simple : Dans l’illustration suivante, si à gauche, le produit proposé en abscisse est positif, à droite, il suffit de déplacer légèrement le point \(B\) pour que le signe de Ph[0]-Ph2[0] ou celui de Ph[0]-Pho[0] change, alors qu’il n’y aurait pas de problème si on prenait l’expression en ordonnée. Mais alors à gauche, le signe de Ph[1]-Ph2[1] change dès que l’on déplace de quelques pixels le point \(B\).
Après différents tests, le choix retenu est celui de prendre le plus grand, en valeur absolue, des deux produits, en abscisses et en ordonnées, soit
ChoixProdPh=(abs((Ph[1]-Pho[1])*(Ph[1]-Ph2[1]))<abs((Ph[0]-Pho[0])*(Ph[0]-Ph2[0])))?((Ph[0]-Pho[0])*(Ph[0]-Ph2[0])):((Ph[1]-Pho[1])*(Ph[1]-Ph2[1]))
Et la partie Prep1H1Ep1 ayant un seul arc de cercle est alors – tant un premier temps – tout simplement
if (ChProdPh<0) {var Prep1H1Ep1=[ListePhoPh,[Ph2G,(Ph2G[1]<0)?BG:HG,PhoG,Pho]];}
C’est une version intermédiaire, on utilisera dans la version finale, une expression utilisant le quadrilatère extérieur LeQD2Pho qui sera précisé plus loin :
if (ChProdPh<0) {var Prep1H1Ep1=[ListePhoPh,LeQD2Pho];}
La liste FinPh3arcs
On l’a déjà dit, le cas le plus élémentaire à caractériser est celui des trois arcs. Le code de la partie Prep1H1Ep1 commence alors ainsi
if (ChProdPh<0) {var Prep1H1Ep1=[ListePhoPh,[Ph2G,(Ph2G[1]<0)?BG:HG,PhoG,Pho]];} else {if (QbPoInHell==1) {var Prep1H1Ep1=[ListeQb2Inter,ListeInterPh,ListePhPh2,FinPh3arcs];} else {... à compléter ...}}
C’est dans la quatrième expression que l’on voit la diversité des situations … où l’on utilise les tests conditionnels imbriqués dans l’écriture compacte du JavaScript.
FinPh3arcs
var tab=[];if (((Ph[0]-Ph2[0])*(Ph[0]-PhQb[0])>0)&&(PhQbEcran==1)) {var tab=[Ph2,PhQb,Qb2]} else {var Ph3aPt1=(Ph2[1]>Ph[1])?(Ph2D[1]>Ph2G[1])?Ph2D:Ph2G:(Ph2D[1]>Ph2G[1])?Ph2G:Ph2D;var Ph3aPt3=(Qb2[1]>Qb[1])?(Qb2D[1]>Qb2G[1])?Qb2D:Qb2G:(Qb2D[1]>Qb2G[1])?Qb2G:Qb2D;var Ph3aPt2=((Ph3aPt1[1]<0)||(Ph3aPt3[1]<0))?BG:HG;var tab=[Ph3aPt1,Ph3aPt2,Ph3aPt3,Qb2]};tab
Ci-dessus le cas où \(PhQb\) est à l’écran, ci-dessous cas où il n’y est plus
Ici, la partie extérieure à l’ellipse est bornée car,hors écran, \(PhQb\) est d’ordonnée positive.
Pour le fun, dans le premier cas, il y a une petite bande verte autour de \(PhQb\). Si on place \(I\) dans cette partie, il y a bien deux perpendiculaires hilbertiennes, verte et rose, différente de la précédente rose (car pas le même type de construction).
Le cas d’une partie avec les deux arcs issus de \(Ph\)
En manipulant la figure, il est clair que l’on passe d’une partie Prep1H1Ep1 avec deux arcs de cercle à une partie hors de l’ellipse (triangle/quadrilatère/pentagone) quand les points \(Ph2\) et \(Pho\) se croisent. On cherche donc une caractérisation. Après avoir testé en vain différentes options avec seulement les coordonnées, l’idée est de se ramener à simplement un angle algébrique. DGPad propose un angle sur 360° ce qui revient au même. Les choses deviennent alors très claires. On note \(aPoP2\) l’angle \(\angle{Pho \, Ph \, Ph2}\).
Ci-dessus, cas d’une droite à pente positive et d’un angle inférieur à 180°,
ci-dessous le cas d’une droite à pente négative et un angle supérieur à 180° (ou négatif).
Le code général associé
Ci dessous la partie dans le else {... à compléter ...} précédent
if (Ph[1]>Pho[1]) {if (((aPoP2<180)&&(penteAB>0))||((aPoP2>180)&&(penteAB<0))) {var Prep1H1Ep1=[ListePhoPh,ListePhPh2,LeQD2Pho]} else {var Prep1H1Ep1=LeQDPh}} else {... à completer ...}
Le code de LeQD2Pho
On construit – directement dans la figure – plusieurs booléens. Tout d’abord un premier, nommé \(QbPoOnQDPhoPh2\) qui teste si le point \(QbPo\) est dans la liste du quadrilatère ou du pentagone extérieur à l’ellipse.
QbPoOnQDPhoPh2
var BorneYPh2Pho=(Pho[1]>Ph[1])?yMax:yMin;(QbPoEcran==1)&&((((QbPo[1]>Ph[1])&&(QbPo[1]<BorneYPh2Pho))&&(Pho[1]>Ph[1]))||(((QbPo[1]<Ph[1])&&(QbPo[1]>BorneYPh2Pho))&&(Pho[1]<Ph[1]))==1)
Pour comparer les positions des points, on utilise la même démarche que pour ChProdPh. C’est le nombre \(ChPh\) qui vaut donc 1 pour le choix en ordonnée et 0 en abscisse. Cela se fait en deux temps, car Ph[TestPhEnY] ne fonctionne pas directement
TestPhEnY = max(abs(Pho[1]-Ph[1]),abs(Ph2[1]-Ph[1]))>max(abs(Pho[0]-Ph[0]),abs(Ph2[0]-Ph[0]))
ChPh = TestPhEnY ? 1:0
Ci dessus on a donné le code général de Prep1H1Ep1 que dans le premier cas où \(Ph\) est au dessus de \(Pho\) mais le code de la partie de Prep1H1Ep1 hors de l’ellipse doit être réaisél pour tous les cas comme ci-dessous ( où Ph[1]<Pho[1], détaillé plus loin)
Ici, la partie extérieure à l’ellipse est non bornée car \(PhQb\), hors écran, est d’ordonnée négative.
LeQD2Pho
var tab=[];if (((Ph[0]-Ph2[0])*(Ph[0]-PhQb[0])>0)&&((QbPoOnQDPh2Pho==1)&&((Pho[0]-QbPo[0])*(Pho[0]-PhQb[0])>0))) {var tab=[PhQb,QbPo,Pho]} else {var QD2PhoPt1=(Ph[ChPh]>Pho[ChPh])?(Ph2G[ChPh]<Ph2[ChPh])?Ph2G:Ph2D:(Ph2G[ChPh]<Ph2D[ChPh])?Ph2D:Ph2G;var QD2PhoPt2=(QD2PhoPt1[1]<0)?BG:HG;var QD2PhoPt2b=(QD2PhoPt1[1]<0)?HG:BG;var QD2PhoPt3=(QbPoOnQDPh2Pho==1)?(Ph[ChPh]>Pho[ChPh])?(Qb2G[ChPh]<Qb2[ChPh])?Qb2G:Qb2D:(Qb2G[ChPh]>Qb2[ChPh])?Qb2G:Qb2D:QD2PhoPt2b;var QD2PhoPt4=(QbPoOnQDPh2Pho==1)?QbPo:(Ph[ChPh]>Pho[ChPh])?(PhoD[ChPh]<Pho[ChPh])?PhoD:PhoG:(PhoG[ChPh]<PhoD[ChPh])?PhoD:PhoG;var tab=[QD2PhoPt1,QD2PhoPt2,QD2PhoPt2b,QD2PhoPt3,QD2PhoPt4,Pho]};tabho];};tab
Le premier if correspond à la première illustration, mais ce n’est pas le cas général, loin de là. On notera que le code du point \(QD2PhoPt2\), pour le choix du coin, est très simple. Il sera plus fouillé pour le cas de LeQD2Qbo.
Fin du code pour la partie Prep1H1Ep1
En explorant en détail la figure, on arrive à cette caractérisation, pour le « else {… à completer …} » restant.
fin du code
if (((Ph[ChPh]>Pho[ChPh])&&((((Pho[1-ChPh]>Ph2[1-ChPh])||(aPoP2>180))&&(penteAB<0))||((Pho[ChPh]<Ph2[ChPh])&&(penteAB>0))))||((Ph[ChPh]<Pho[ChPh])&&(Pho[ChPh]>Ph2[ChPh])&&(penteAB>0))) {var Prep1H1Ep1=[ListePhoPh,ListePhPh2,LeQD2Pho]} else {var Prep1H1Ep1= LeQDPh}
Le code de la partie hors ellipse en \(Ph\)
LeQDPh
var QDPhPt1=(QbPoOnQDPh==1)?QbPo:(Ph[ChPh]<Pho[ChPh])?(PhoG[ChPh]>0)?PhoD:PhoG:(PhoG[ChPh]<PhoD[ChPh])?PhoD:PhoG;var QDPhPt2=(QbPoOnQDPh==0)?(QDPhPt1[1]<0)?BG:HG:(Ph[ChPh]<Pho[ChPh])?(Qb2G[ChPh]>Qb2[ChPh])?Qb2D:Qb2G:(Qb2G[ChPh]<Qb2D[ChPh])?Qb2D:Qb2G;var QDPhPt4=(Ph[ChPh]<Ph2[ChPh])?(Ph2G[ChPh]>Ph2[ChPh])?Ph2D:Ph2G:(Ph2G[ChPh]<Ph2D[ChPh])?Ph2D:Ph2G;var QDPhPt3 =(QDPhPt4[1]<0)?BG:HG;var QDPh=[Ph,QDPhPt1,QDPhPt2,QDPhPt3, QDPhPt4,Ph];QDPh
Le code complet de Prep1H1Ep1
if (ChProdPh<0) {var Prep1H1Ep1=[ListePhoPh,LeQD2Pho];} else {if (QbPoInHell==1) {var Prep1H1Ep1=[ListeQb2Inter,ListeInterPh,ListePhPh2, FinPh3arcs];} else {if (Ph[1]>Pho[1]) {if (((aPoP2<180)&&(penteAB>0))||((aPoP2>180)&&(penteAB<0))) {var Prep1H1Ep1=[ListePhoPh,ListePhPh2,LeQD2Pho]} else {var Prep1H1Ep1=LeQDPh}} else {if (((Ph[ChPh]>Pho[ChPh])&&((((Pho[1-ChPh]>Ph2[1-ChPh])||(aPoP2>180))&&(penteAB<0))||((Pho[ChPh]<Ph2[ChPh])&&(penteAB>0))))||((Ph[ChPh]<Pho[ChPh])&&(Pho[ChPh]>Ph2[ChPh])&&(penteAB>0))) {var Prep1H1Ep1=[ListePhoPh,ListePhPh2,LeQD2Pho]} else {var Prep1H1Ep1= LeQDPh};};};}
La partie Prep1H1Ep2
Nous irons plus rapidement, la démarche est identique, parfois plus simple car il y a moins de cas à traiter. Il y a bien entendu de petits ajustements que nous allons détailler.
Quelques illustrations
Cas de 2 arcs en \(Qb\) avec \(PhQb\) et \(PhQo\) de part et d’autres de \((AB)\)
… pour une spécificité du code LaQDPh comme ici \([PhQb, QbPo, Ph]\)
Cas de 3 arcs en \(Qb\) avec avec la partie extérieure non bornée, dans deux illustrations
ci-dessus avec le triangle en \(Ph\), ci dessous avec les parties extérieures très allongées.
La partie en \(Ph\) est bornée, celle en \(Qb\) ne l’est pas.
Le code complet de Prep1H1Ep2
if (ChProdQb<0) {var Prep1H1Ep2=[ListeQbQbo,LeQD2Qbo];} else {if (PhQoInHell==1) {var Prep1H1Ep2=[ListeQb2Qb,ListeQbInter,ListeInterPh2,FinQb3arcs];} else {if (Qb[1]>Qbo[1]) {if (((aQoQ2>180)&&(penteAB>0))||((aQoQ2<180)&&(penteAB<0))) {var Prep1H1Ep2=[ListeQb2Qb,ListeQbQbo,LeQD2Qbo]} else {var Prep1H1Ep2=LeQDQb}} else {if ((Qb[1]<Qbo[1])&&(((aQoQ2<180)&&(penteAB>0))||((aQoQ2>180)&&(penteAB<0)))) {var Prep1H1Ep2=[ListeQb2Qb,ListeQbQbo,LeQD2Qbo]} else {var Prep1H1Ep2= LeQDQb};};};}
Quelques spécificités pour Prep1H1Ep2
TestQbEnY : on ajoute le OU pour éviter la verticalité de (Qb Qbo)
(max(abs(Qbo[1]-Qb[1]),abs(Qb2[1]-Qb[1]))>max(abs(Qbo[0]-Qb[0]),abs(Qb2[0]-Qb[0])))||(abs(Qbo[0]-Qb[0])<0.01)
Mais cet ajout apporte un problème – sur quelques pixels – quand \(Qbo\) traverse \(Qb\). On maintient néanmoins cette modification, pour le cas général.
FinQb3arcs
var tab=[]; if (((Ph[0]-Ph2[0])*(Ph[0]-PhQb[0])>0)&&(PhQbEcran==1)) {var tab=[Ph2,PhQb,Qb2]} else {var QD3aPt1=(Ph2[1]<Ph[1])?(Ph2D[1]<Ph2G[1])?Ph2D:Ph2G:(Ph2D[1]<Ph2G[1])?Ph2G:Ph2D;var QD3aPt2=(Qb2[1]<Qb[1])?(Qb2D[1]<Qb2G[1])?Qb2D:Qb2G:(Qb2D[1]<Qb2G[1])?Qb2G:Qb2D;var tab=[QD3aPt1,QD3aPt2,Qb2];};tab
LeQDQb
var tab=[];if (((PhQoOnQDQb ==1)&&(PhQbEcran==1))&&((Qb[0]-Qb2[0])*(Qb[0]-PhQo[0])<0)) {if ((Qb[0]-PhQb[0])*(Qb[0]-PhQo[0])>0) {var tab=[Qb,PhQo,PhQb,Qb,Qb]} else {var tab=[Qb,PhQo,Ph2G,HG,Qb2G,Qb]}} else {var QDQbPt1=(PhQoOnQDQb ==1)?PhQo:(Qb[ChQb]<Qbo[ChQb])?(QboG[ChQb]>0)?QboD:QboG:(QboG[ChQb]<QboD[ChQb])?QboD:QboG;var QDQbPt2=(PhQoOnQDQb ==0)?(QDQbPt1[1]<0)?BG:HG:(Qb[ChQb]<Qbo[ChQb])?(Ph2G[ChQb]>Ph2[ChQb])?Ph2D:Ph2G:(Ph2G[ChQb]<Ph2D[ChQb])?Ph2D:Ph2G;var QDQbPt4=(Qb[ChQb]<Qbo[ChQb])?(Qb2G[ChQb]>Qb2[ChQb])?Qb2D:Qb2G:(Qb2G[ChQb]<Qb2D[ChQb])?Qb2D:Qb2G;var QDQbPt3 =(QDQbPt4[1]<0)?BG:HG;var tab=[Qb,QDQbPt1,QDQbPt2,QDQbPt3, QDQbPt4,Qb];};tab
LeQD2Qbo
var tab=[];if (((Ph[0]-Ph2[0])*(Ph[0]-PhQb[0])>0)&&((QbPoOnQDPh2Pho==1)&&((Pho[0]-QbPo[0])*(Pho[0]-PhQb[0])>0))) {var tab=[PhQb,QbPo,Pho]} else {var QD2PhoPt1=(Ph[ChPh]>Pho[ChPh])?(Ph2G[ChPh]<Ph2[ChPh])?Ph2G:Ph2D:(Ph2G[ChPh]<Ph2D[ChPh])?Ph2D:Ph2G;var QD2PhoPt2=(QD2PhoPt1[1]<0)?BG:HG;var QD2PhoPt2b=(QD2PhoPt1[1]<0)?HG:BG;var QD2PhoPt3=(QbPoOnQDPh2Pho==1)?(Ph[ChPh]>Pho[ChPh])?(Qb2G[ChPh]<Qb2[ChPh])?Qb2G:Qb2D:(Qb2G[ChPh]>Qb2[ChPh])?Qb2G:Qb2D:QD2PhoPt2b;var QD2PhoPt4=(QbPoOnQDPh2Pho==1)?QbPo:(Ph[ChPh]>Pho[ChPh])?(PhoD[ChPh]<Pho[ChPh])?PhoD:PhoG:(PhoG[ChPh]<PhoD[ChPh])?PhoD:PhoG;if (abs(QD2PhoPt1[1]-QD2PhoPt4[1])<0.01) {var tab=[QD2PhoPt1,QD2PhoPt4,Pho]} else {var tab=[QD2PhoPt1,QD2PhoPt2,QD2PhoPt2b,QD2PhoPt3,QD2PhoPt4,Pho]}};tab
Le dernier point est paramétré pour que l’expression serve pour un ou deux arcs.
On pourrait être surpris de cette écriture var tab=[Qb,PhQo,PhQb,Qb,Qb] avec les deux \(Qb\). Cela résulte de l »applatissement des listes de Prep1H1Ep1 et Prep1H1Ep2 qui sont des listes de listes. Avec les 3 arcs, elles sont composées de 4 listes. D’où le choix de décider que si ces deux parties sont de longueur 5 ou plus, elles sont une simple liste. D’où le double d’un point ci-dessus pour avoir une longueur 5.
Code général d’applatissement qui relie les quatre parties en une seule liste
var LGene=Prep1H1Ep1;var n=(LGene).length;if (n<5) {for (var i=0;i<n;i++){var ni=(LGene[i]).length;for (var ii=0;ii<ni;ii++){var k= LGene[i][ii];tab.push(k)};};tab.push(LGene[0][0]);} else {for (var i=0;i<n;i++){var k= LGene[i];tab.push(k)};tab.push(LGene[0]);};tab.push([NaN,NaN]);var LGene=Prep1H1Ep2;var n=(LGene).length;if (n<5) {for (var i=0;i<n;i++){var ni=(LGene[i]).length;for (var ii=0;ii<ni;ii++){var k= LGene[i][ii];tab.push(k)};};tab.push(LGene[0][0]);} else {for (var i=0;i<n;i++){var k= LGene[i];tab.push(k)};tab.push(LGene[0]);};tab.push([NaN,NaN]);var LGene=Prep1H1Ep3; var n=(LGene).length;if (n>1) {for (var i=0;i<n;i++){var k= LGene[i];tab.push(k)};tab.push(LGene[0]);tab.push([NaN,NaN]);};var LGene=Prep1H1Ep4; var n=(LGene).length;if (n>1) {for (var i=0;i<n;i++){var k= LGene[i];tab.push(k)};tab.push(LGene[0]);};tab
Le code final de l’expression qui construit la partie 1H1E
Il est finalement assez compact car les vraies difficultées/subtilités sont reportées dans les listes de polygones en dehors de l’ellipse, ou enventuellement es les booléens utilisés comme TestPhEnY et TestQbEnY.
exp1H1E
var tab=[];var Prep1H1Ep1=[]; Prep1H1Ep2=[];var Prep1H1Ep3=[];var Prep1H1Ep4=[];if ((PhQoEcran==1)&&(PhQo[0]>PhQb[0])) {var Prep1H1Ep4=[PhQo,Ph2D,(QboD[1]<0)?BD:HD,QboD,PhQo]};if ((QbPoEcran==1)&&(QbPo[0]>PhQb[0])) {var Prep1H1Ep3=[QbPo,PhoD,((Qb2D[1]<0)||(PhoD[1]<0))?BD:HD,Qb2D,QbPo]} else {if ((PhQbEcran==1)&&(PhQo[0]<PhQb[0])){var Prep1H1Ep4=[PhQb,Ph2D,(abs(Ph2D[1]-yMin)<0.001==1)?BD:HD,Qb2D,PhQb]}};if (ChProdPh<0) {var Prep1H1Ep1=[ListePhoPh,LeQD2Pho];} else {if (QbPoInHell==1) {var Prep1H1Ep1=[ListeQb2Inter,ListeInterPh,ListePhPh2, FinPh3arcs];} else {if (Ph[1]>Pho[1]) {if (((aPoP2<180)&&(penteAB>0))||((aPoP2>180)&&(penteAB<0))) {var Prep1H1Ep1=[ListePhoPh,ListePhPh2,LeQD2Pho]} else {var Prep1H1Ep1=LeQDPh}} else {if (((Ph[ChPh]>Pho[ChPh])&&((((Pho[1-ChPh]>Ph2[1-ChPh])||(aPoP2>180))&&(penteAB<0))||((Pho[ChPh]<Ph2[ChPh])&&(penteAB>0))))||((Ph[ChPh]<Pho[ChPh])&&(Pho[ChPh]>Ph2[ChPh])&&(penteAB>0))) {var Prep1H1Ep1=[ListePhoPh,ListePhPh2,LeQD2Pho]} else {var Prep1H1Ep1= LeQDPh};};};};if (ChProdQb<0) {var Prep1H1Ep2=[ListeQbQbo,LeQD2Qbo];} else {if (PhQoInHell==1) {var Prep1H1Ep2=[ListeQb2Qb,ListeQbInter,ListeInterPh2,FinQb3arcs];} else {if (Qb[1]>Qbo[1]) {if (((aQoQ2>180)&&(penteAB>0))||((aQoQ2<180)&&(penteAB<0))) {var Prep1H1Ep2=[ListeQb2Qb,ListeQbQbo,LeQD2Qbo]} else {var Prep1H1Ep2=LeQDQb}} else {if ((Qb[1]<Qbo[1])&&(((aQoQ2<180)&&(penteAB>0))||((aQoQ2>180)&&(penteAB<0)))) {var Prep1H1Ep2=[ListeQb2Qb,ListeQbQbo,LeQD2Qbo]} else {var Prep1H1Ep2= LeQDQb};};};};var LGene=Prep1H1Ep1;var n=(LGene).length;if (n<5) {for (var i=0;i<n;i++){var ni=(LGene[i]).length;for (var ii=0;ii<ni;ii++){var k= LGene[i][ii];tab.push(k)};};tab.push(LGene[0][0]);} else {for (var i=0;i<n;i++){var k= LGene[i];tab.push(k)};tab.push(LGene[0]);};tab.push([NaN,NaN]);var LGene=Prep1H1Ep2;var n=(LGene).length;if (n<5) {for (var i=0;i<n;i++){var ni=(LGene[i]).length;for (var ii=0;ii<ni;ii++){var k= LGene[i][ii];tab.push(k)};};tab.push(LGene[0][0]);} else {for (var i=0;i<n;i++){var k= LGene[i];tab.push(k)};tab.push(LGene[0]);};tab.push([NaN,NaN]);var LGene=Prep1H1Ep3; var n=(LGene).length;if (n>1) {for (var i=0;i<n;i++){var k= LGene[i];tab.push(k)};tab.push(LGene[0]);tab.push([NaN,NaN]);};var LGene=Prep1H1Ep4; var n=(LGene).length;if (n>1) {for (var i=0;i<n;i++){var k= LGene[i];tab.push(k)};tab.push(LGene[0]);};tab
La figure finale à manipuler
Dans cette figure, déplacer les points \(A, B\) et \(I\).
Préférer utiliser cette figure plus grande dans un nouvel onglet.