Octogones, pavage et rosaces Renée De Graeve 2019

Contents

• 1  Les octogones
  • 1.1  Exercice1
  • 1.2  Exercice2
  • 1.3  Le programme
  • 1.4  La ronde de 4 octogones autour d’un octogone central
  • 1.5  La ronde de 8 octogones autour d’un octogone central
• 2  Le pavage avec un octogone régulier et un carré
  • 2.1  Juxtaposition des octogones
  • 2.2  Les médianes des carrés manquants
  • 2.3  Le pavage
• 3  Les octogones en couleur
  • 3.1  Les octogones avec 2 couleurs
  • 3.2  Les octogones avec plusieurs couleurs
  • 3.3  Les 9 octogone colorés
  • 3.4  La ronde des 37=4*9+1 octogones
• 4  Le pavage en couleur
• 5  Les rosaces en couleur
  • 5.1  la procédure rosaceocto
  • 5.2  la procédure rosaceoctogone
  • 5.3  Le pavage avec les rosaces octogonales

1  Les octogones

On veut tracer la figure suivante :
axes=0;octogone(0,0,5); exe

Elle est composée d’un octogone et d’un carré central. Les côtés du carré sont parallèles aux côtés de l’octogone et ont la même longueur que ceux de l’octogone. Puis, on trace les médianes de l’octogone qui sont aussi les médianes du carré et les segments reliant les sommets du carré aux côtés de l’octogone en leur étant perpendiculaires.

1.1  Exercice1

Quelle est la longueur $l$ du côté d’un octogone régulier inscrit dans un cercle de rayon $r$ ?
Comment peut-on construire le carré à partir de l’octogone régulier ?
Si on prend comme axes $Ox$ et $Oy$ des droites parallèles aux diagonales du carré centré en $O$, quelles sont les coordonnées des sommets du carré ?
Réponse1
La longueur $l$ du côté d’un octogone régulier inscrit dans un cercle de rayon $r$ est égale à $l=2r\sin(\frac{\pi}{8})$.
axes=0;O:=point(0);isopolygone(0,exp(i*pi/8),-8);A,B,C,D,E,F,G,H:=sommets(isopolygone(0,exp(i*pi/8),-8));segment(A,F),segment(B,E),segment(C,H),segment(D,G),segment(C,H) exe
À partir de l’octogone régulier $ABCDEFGH$, on construit les sommets $P$ (resp $Q,R,S$) du carré comme les intersections des segments $AF$ et $CH$ (resp $BE$ et $CH$, $BE$ et $DG$, $AF$ et $DG$).
axes=0;O:=point(0);octogone(0,0,5);A,B,C,D,E,F,G,H:=sommets(isopolygone(0,5*exp(i*pi/8),-8)):;P:=point(5*sqrt(2)*sin(pi/8)):;Q:=point(i*5*sqrt(2)*sin(pi/8));R:=point(-5*sqrt(2)*sin(pi/8));S:=point(-i*5*sqrt(2)*sin(pi/8));M:=point(5*cos(pi/8));N:=point(5*i*cos(pi/8));A:=A;B:=B;C:=C;F:=F;H:=H;I:=milieu(A,B);J:=milieu(P,Q);affichage([segment(A,F),segment(C,H),P],1); exe

On note $I$ le milieu de $AB$ et $J$ le milieu de $PQ$.
On remarquera que les triangles $JOP$ et $MAP$ sont des triangles rectangles isocèles égaux $$AM=IA=JP=\frac{l}{2}=r\sin(\frac{\pi}{8}) \ \mbox{et}\ AP=IJ=OP=l\frac{\sqrt{2}}{2}=r\sqrt{2}\sin(\frac{\pi}{8})$$ Les affixes des sommets du carré sont : $$r\sqrt{2}\sin(\frac{\pi}{8}),\ i r\sqrt{2}\sin(\frac{\pi}{8}),\ -r\sqrt{2}\sin(\frac{\pi}{8}),\ -i r\sqrt{2}\sin(\frac{\pi}{8})$$

1.2  Exercice2

On veut pouvoir emboiter les octogones, c’est pourquoi les côtés du carré doivent avoir la même longueur que ceux de l’octogone.
Montrer que $OM=r\cos(\frac{\pi}{8})$ et en déduire que $OP=r(\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8})$).
En déduire, la formule $\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8})=\sqrt{2}\sin(\frac{\pi}{8})$ et le calcul des valeurs de $\sin(\frac{\pi}{8})$ et $\cos(\frac{\pi}{8})$.
Réponse2
L’angle $\widehat{MOA}=\frac{\pi}{8}$ et $OA=r$ donc $OM=r\cos(\frac{\pi}{8})$.
On a montré précédemment que $PM=l/2=r\sin(\frac{\pi}{8})$ et $0P=l\sqrt{2}/2=r\sqrt{2}\sin(\frac{\pi}{8})$ donc : $$OP=r\sqrt{2}\sin(\frac{\pi}{8})=OM-PM=r(\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8}))$$ Donc $\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8})=\sqrt{2}\sin(\frac{\pi}{8})$.
On a donc : $$\cos(\frac{\pi}{8})=\sin(\frac{\pi}{8})(1+\sqrt{2}) \ \mbox{ et } \ \cos(\frac{\pi}{8})^2=1-\sin(\frac{\pi}{8})^2$$ donc : $$1-\sin(\frac{\pi}{8})^2=\cos(\frac{\pi}{8})^2=(1+\sqrt{2})^2\sin(\frac{\pi}{8})^2=(3+2\sqrt{2})\sin(\frac{\pi}{8})^2$$ On obtient : $$\sin(\frac{\pi}{8}))^2=\frac{2-\sqrt{2}}{4} \ \mbox{et} \ \cos(\frac{\pi}{8})^2=\frac{2+\sqrt{2}}{4}$$ Puisque $\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8})>0$ et $\sin(\frac{\pi}{8})>0$, on en déduit :
$$\sin(\frac{\pi}{8})=\frac{\sqrt {2-\sqrt{2} }}{2} \ \mbox{ et }\ \cos(\frac{\pi}{8})=\frac{\sqrt{2+\sqrt{2} }}{2})$$ On a donc :
$$OJ=PM=AM=r\sin(\frac{\pi}{8}) \ \mbox{ et } \ JI=OP=r\sqrt{2}\sin(\frac{\pi}{8})$$

1.3  Le programme

Le programme octogone trace l’octogone la figure désirée.
octogone a pour coordonnées l’affixe z du centre de l’octogone, $t$ l’angle que fait une diagonale du carré avec $Ox$ et $r$ le rayon du cercle circonscrit à l’octogone. On utilise comme variable locale a qui représente la longueur de $OP=r*(\cos(\frac{\pi}{8})-\sin(\frac{\pi}{8}))=r\sqrt{2} \sin(\frac{\pi}{8})$ i.e la moitié de la longueur de la diagonale du carré.
En syntaxe Xcas :

octogone(z,t,r):={
  local L,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,isopolygone(z,z+r*exp(i*pi/8+i*t),-8);
  L:=L,carre(z+a*exp(i*t),z+a*i*exp(i*t));
  L:=L,segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8))$(k=0..3); // $ genere une sequence
  L:=L,segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t));
  L:=L,segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t));
  return L;
}:;

exeonload
En syntaxe Python

def octogone(z,t,r):
    # local L,a,k
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    L.append(isopolygone(z,z+r*exp(i*pi/8+i*t),-8))
    L.append(carre(z+a*exp(i*t),z+a*i*exp(i*t)))
    L.append([segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)) for k in range(4)])
    L.append(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)))
    L.append(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)))
    return L

exe
axes=0;octogone(0,0,5);octogone(10,pi/4,4),octogone(18,pi/8,3) exe

1.4  La ronde de 4 octogones autour d’un octogone central

On veut tracer 4 octogones autour d’un octogone central.
axes=0;octogone(0,0,5);octogone(5*cos(pi/8)*(1+i),0,5);octogone(5*cos(pi/8)*(-1+i),0,5);octogone(5*cos(pi/8)*(-1-i),0,5);octogone(5*cos(pi/8)*(1-i),0,5); exe

En syntaxe Xcas :

octogone5(z,t,r):={
  local L,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,octogone(z,t,r);
  pour k de 1 jusque 7 pas 2 faire 
    L:=L,octogone(z+r*sqrt(2)*cos(pi/8)*exp(i*t+i*k*pi/4),t,r);
  fpour;
  return L;
}:;

exeonload
En syntaxe Python :

def octogone5(z,t,r):
    # local L,a,k
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    L.append(octogone(z,t,r))
    k=1
    while k<=7 :
        L.append(octogone(z+r*sqrt(2)*cos(pi/8)*exp(i*t+i*k*pi/4),t,r))
        k=k+2
    return(L)

exe
axes=0;octogone5(-18,0,4);octogone5(0,pi/8,4);octogone5(18,pi/4,4); exe

1.5  La ronde de 8 octogones autour d’un octogone central

On veut tracer 8 octogones autour d’un octogone central.
axes=0;octogone(0,0,4),octogone((8*cos(pi/8)-4*sqrt(2)*sin(pi/8))*exp(k*i*pi/2+i*pi/4),0,4)$(k=0..3),octogone(2*4*cos(pi/8)*exp(i*k*pi/2),0,4)$(k=0..3) exe

En syntaxe Xcas :

octogone9(z,t,r):={
  local L,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,octogone(z,t,r);
  pour k de 0 jusque 3 faire 
    L:=L,octogone(z+(r*2*cos(pi/8)-a)*exp(i*t+i*k*pi/2+i*pi/4),t,r);
    L:=L,octogone(z+2*r*cos(pi/8)*exp(i*t+i*k*pi/2),t,r);
  fpour;
  return L;
}:;

exeonload
En syntaxe Python :

def octogone9(z,t,r):
    # local L,a,k
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    L.append(octogone(z,t,r))
    for k in range(4):
        L.append(octogone(z+(r*2*cos(pi/8)-a)*exp(i*t+i*k*pi/2+i*pi/4),t,r))
        L.append(octogone(z+2*r*cos(pi/8)*exp(i*t+i*k*pi/2),t,r))
    return(L)

exe
axes=0;octogone9(-21,0,4);octogone9(0,pi/4,4);octogone9(20,pi/8,4); exe
On peut continuer le pavage, mais il y beaucoup de recouvrements et on dessine plusieurs fois la même chose :
axes=0;affichage(octogone9(28+(12*cos(pi/8)-6*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3),3+k)$(k=0..3);affichage(octogone9(-23,0,3),1);affichage(octogone9(6*cos(pi/8)*exp(i*k*pi/2),0,3),3+k)$(k=0..3); exe

axes=0;affichage(octogone9(0+(12*cos(pi/8)-6*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3),3+k)$(k=0..3);affichage(octogone9(6*cos(pi/8)*exp(i*k*pi/2),0,3),3+k)$(k=0..3);affichage(octogone(0,0,3),1) exe

axes=0;octogone9(0,0,3),octogone9((12*cos(pi/8)-6*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3)$(k=0..3),octogone9(6*cos(pi/8)*exp(i*k*pi/2),0,3)$(k=0..3) exe

2  Le pavage avec un octogone régulier et un carré

Pour éviter des recouvrements on va écrire une procédure qui recouvre un rectangle ayant $q$ lignes contenant chacune $p$ octogones faisant un angle nul avec l’axe des $x$ et qui juxtapose les octogones précédents, puis on comblera les vides avec une autre procédure qui dessinera les médianes des carrés manquants.
Ces procédures auront les mêmes paramètres qui sont :

• $z$ l’affixe du centre de l’octogne situé en $p=0$ et $q=0$,
• $t$ la mesure de l’angle que font la ligne des centres avec l’axe des $x$
• $r$ la longueur d’un côté de l’octogone qui es aussi la longueur d’un côté du carré,
• $p$ le nombre d’octognes sur une ligne et $q$ le nombre d’octognes sur une colonne.

2.1  Juxtaposition des octogones

La fonction octogonejux dessine les octogones juxtaposés. En syntaxe Xcas

octogonejux(z,t,r,p,q):={
  local L,j,k;
  L:=NULL;
  r:=evalf(r);
  pour j de 0 jusque q-1 faire 
    pour k de 0 jusque p-1 faire 
      L:=L,octogone(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r);
    fpour;
  fpour;
  return L;
}:;

exeonload
En syntaxe Python :

def octogonejux(z,t,r,p,q):
    # local L,j,k
    r=float(r)
    L=seq[]
    for j in range(q):
        for k in range(p):
            L=L,octogone(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r)
    return(L)

exe
axes=0;octogonejux(0,0,3,7,4) exe

axes=0;octogonejux(-17,pi/6,3,3,3),octogonejux(0,0,3,3,3),octogonejux(27,pi/3,3,3,3) exe

2.2  Les médianes des carrés manquants

La fonction medianes dessine les médianes des carrés manquants. On utilise comme variables locales :

• b la moitié de la longueur d’un côté du carré,
• A le centre du carré,
• k l’indice de la ligne,
• j l’indice de la colonne.

medianes(z,t,r,p,q):={
  local L,j,k,b,A;
  L:=NULL;
  r:=evalf(r);
  b:=r*sin(pi/8);
  pour j de 0 jusque q-2 faire 
    pour k de 0 jusque p-2 faire 
      A:=point(z+(r*cos(pi/8)+b)*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t));
      L:=L,segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t));
      L:=L,segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t));
    fpour;
  fpour;
  return L;
}:;

exeonload
En syntaxe Python :

def medianes(z,t,r,p,q):
    # local L,j,k,b,A
    L=[]
    r=float(r)
    b=r*sin(pi/8)
    for j in range(q-1):
        for k in range(p-1):
            A=point(z+(r*cos(pi/8)+b)*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t))
            L.append(segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t)))
            L.append(segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t)))
    return(L)

exe
octogonejux(-17,pi/6,3,3,3),medianes(-17,pi/6,3,3,3),octogonejux(0,0,3,3,3),medianes(0,0,3,3,3),octogonejux(27,pi/3,3,3,3),medianes(27,pi/3,3,3,3) exe

2.3  Le pavage

La fonction octogonepave réunit les 2 procédures précédentes et dessine le pavage du rectangle ayant $q$ lignes contenant chacune $p$ octogones. En syntaxe Xcas :

octogonepave(z,t,r,p,q):={
  local L;
  L:=NULL;
  L:=L,octogonejux(z,t,r,p,q);
  L:=L,medianes(z,t,r,p,q);
  return L;
}:;

exeonload
En syntaxe Python :

def octogonepave(z,t,r,p,q):
    return octogonejux(z,t,r,p,q),medianes(z,t,r,p,q)

exe
octogonepave(-17,pi/6,3,3,3),octogonepave(0,0,3,3,3), octogonepave(27,pi/3,3,3,3) exe

3  Les octogones en couleur

3.1  Les octogones avec 2 couleurs

Dans un premier temps, on remplit l’octogne d’une couleur, puis on remplit le carré d’une autre couleur, enfin on trace les segments et les contours en noir et en épaisseur 3.

En syntaxe Xcas :

octogonep(z,t,r,c1,c2):={
  local L,a;
  L:=[];
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,affichage(isopolygone(z,z+r*exp(i*pi/8)*exp(i*t),-8),c1+rempli);
  L:=L,affichage(isopolygone(z,z+r*exp(i*pi/8)*exp(i*t),-8),epaisseur_ligne_3);
  L:=L,affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),c2+rempli);
  L:=L,affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8))$(k=0..3),epaisseur_ligne_3); // $
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),0+epaisseur_ligne_3);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3);
  return L;
}:;

exeonload
La traduction en syntaxe Python :

def octogonep(z,t,r,c1,c2):
    # local L,a
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    L.append(affichage(isopolygone(z,z+r*exp(i*pi/8)*exp(i*t),-8),c1+rempli))
    L.append(affichage(isopolygone(z,z+r*exp(i*pi/8)*exp(i*t),-8),epaisseur_ligne_3))
    L.append(affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),c2+rempli))
    L.append(affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),epaisseur_ligne_3))
    L.append(affichage([segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)) for k in range(4)],epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),0+epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3))
    return(L)

exe
axes=0;octogonep(-10,0,5,1,3);octogonep(0,pi/8,5,4,2);octogonep(10,pi/3,5,6,5); exe
axes=0;octogonep(0,0,4,4,6),octogonep((8*cos(pi/8)-4*sqrt(2)*sin(pi/8))*exp(3*i*pi/4),0,4,4,6),octogonep((8*cos(pi/8)-4*sqrt(2)*sin(pi/8))*exp(i*pi/4),0,4,4,6) exe

axes=0;octogonep(0,0,4,4,6),octogonep((8*cos(pi/8)-4*sqrt(2)*sin(pi/8))*exp(k*i*pi/2+i*pi/4),0,4,4,3)$(k=0..3),octogonep(2*4*cos(pi/8)*exp(i*k*pi/2),0,4,4,6)$(k=0..3) exe

3.2  Les octogones avec plusieurs couleurs

On décide d’utiliser 3 couleurs.

octogonep3c(z,t,r,c1,c2,c3):={
  local L,k,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  pour k de 0 jusque 3 faire 
    L:=L,affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*exp(3*i*pi/8+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*k*pi/2),z+a*exp(i*t+i*pi/2+i*k*pi/2)),c2+irem(k,2)+rempli);
    L:=L,affichage(polygone(z+a*exp(i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*t+i*k*pi/2),z+r*exp(i*pi/8+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi/2)),c1+irem(k,2)+rempli);
  fpour;
  L:=L,affichage(isopolygone(z,z+r*exp(i*pi/8+i*t),-8),epaisseur_ligne_3);
  L:=L,affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),c3+rempli);
  L:=L,affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8))$(k=0..3),epaisseur_ligne_3); // $
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3);
  return L;
}:;

exeonload
En syntaxe Python :

def octogonep3c(z,t,r,c1,c2,c3):
    # local L,k,a
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    for k in range(4):
        L.append(affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*exp(3*i*pi/8+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*k*pi/2),z+a*exp(i*t+i*pi/2+i*k*pi/2)),c2+k % 2+rempli))
        L.append(affichage(polygone(z+a*exp(i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*t+i*k*pi/2),z+r*exp(i*pi/8+i*t+i*k*pi/2),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi/2),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi/2)),c1+k % 2+rempli))
    L.append(affichage(isopolygone(z,z+r*exp(i*pi/8+i*t),-8),epaisseur_ligne_3))
    L.append(affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),c3+rempli))
    L.append(affichage(carre(z+a*exp(i*t),z+a*i*exp(i*t)),epaisseur_ligne_3))
    L.append(affichage([segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)) for k in range(4)],epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3))
    return(L)

exe
axes=0;octogonep3c(0,0,3,1,4,3) exe

axes=0;octogonep3c(20,0,3,120,125,115) exe

On décide d’utiliser 5 couleurs. En syntaxe Xcas :

octogonep5c(z,t,r,c1,c2,c3,c4,c5):={
  local L,k,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  pour k de 0 jusque 1 faire 
    L:=L,affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*exp(3*i*pi/8+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*k*pi),z+a*exp(i*t+i*pi/2+i*k*pi)),c2+rempli);
    L:=L,affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*exp(3*i*pi/8+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*pi/2+i*k*pi),z+a*exp(i*t+i*pi/2+i*pi/2+i*k*pi)),c4+rempli);
    L:=L,affichage(polygone(z+a*exp(i*t+i*k*pi),z+r*cos(pi/8)*exp(i*t+i*k*pi),z+r*exp(i*pi/8+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi)),c1+rempli);
    L:=L,affichage(polygone(z+a*exp(i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*t+i*pi/2+i*k*pi),z+r*exp(i*pi/8+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi)),c3+rempli);
  fpour;
  L:=L,affichage(isopolygone(z,z+r*exp(i*pi/8+i*t),-8),epaisseur_ligne_3);
  L:=L,affichage(carre(z+a*exp(i*t),z+r*sqrt(2)*sin(pi/8)*i*exp(i*t)),c5+rempli);
  L:=L,affichage(carre(z+a*exp(i*t),z+r*sqrt(2)*sin(pi/8)*i*exp(i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8))$(k=0..3),epaisseur_ligne_3); // $
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3);
  return L;
}:;

exeonload
En syntaxe Python :

def octogonep5c(z,t,r,c1,c2,c3,c4,c5):
    # local L,k,a
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    for k in range(2):
        L.append(affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*exp(3*i*pi/8+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*k*pi),z+a*exp(i*t+i*pi/2+i*k*pi)),c2+rempli))
        L.append(affichage(polygone(z+r*sin(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*exp(3*i*pi/8+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/2+i*t+i*pi/2+i*k*pi),z+a*exp(i*t+i*pi/2+i*pi/2+i*k*pi)),c4+rempli))
        L.append(affichage(polygone(z+a*exp(i*t+i*k*pi),z+r*cos(pi/8)*exp(i*t+i*k*pi),z+r*exp(i*pi/8+i*t+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*k*pi),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*k*pi)),c1+rempli))
        L.append(affichage(polygone(z+a*exp(i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*t+i*pi/2+i*k*pi),z+r*exp(i*pi/8+i*t+i*pi/2+i*k*pi),z+r*cos(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi),z+r*sin(pi/8)*exp(i*pi/4+i*t+i*pi/2+i*k*pi)),c3+rempli))
    L.append(affichage(isopolygone(z,z+r*exp(i*pi/8+i*t),-8),epaisseur_ligne_3))
    L.append(affichage(carre(z+a*exp(i*t),z+r*sqrt(2)*sin(pi/8)*i*exp(i*t)),c5+rempli))
    L.append(affichage(carre(z+a*exp(i*t),z+r*sqrt(2)*sin(pi/8)*i*exp(i*t)),epaisseur_ligne_3))
    L.append(affichage([segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)) for k in range(4)],epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3))
    return(L)

exe
axes=0;octogonep5c(0,0,1,4,2,5,3,6) exe

axes=0;octogonep5c(20,0,3,114,122,118,126,110) exe

3.3  Les 9 octogone colorés

On tape:

octogone9p3c(z,t,r,c1,c2,c3):={
  local L,k,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,octogonep3c(z,t,r,c1,c2,c3);
  pour k de 0 jusque 3 faire 
    L:=L,octogonep3c(z+(2*r*cos(pi/8)-a)*exp(k*i*pi/2+i*pi/4),t,r,c1,c2,c3);
    L:=L,octogonep3c(z+2*r*cos(pi/8)*exp(i*k*pi/2),t,r,c1,c2,c3);;
  fpour;
  return L;
}:;
octogone9p5c(z,t,r,c1,c2,c3,c4,c5):={
  local L,k,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,octogonep5c(z,t,r,c1,c2,c3,c4,c5);
  pour k de 0 jusque 3 faire 
    L:=L,octogonep5c(z+(2*r*cos(pi/8)-a)*exp(k*i*pi/2+i*pi/4),t,r,c1,c2,c3,c4,c5);
    L:=L,octogonep5c(z+2*r*cos(pi/8)*exp(i*k*pi/2),t,r,c1,c2,c3,c4,c5);;
  fpour;
  return L;
}:;

exeonload

def octogone9p3c(z,t,r,c1,c2,c3):
    # local L,k,a
    L=seq[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    L=L,octogonep3c(z,t,r,c1,c2,c3)
    for k in range(4):
        L=L,octogonep3c(z+(2*r*cos(pi/8)-a)*exp(k*i*pi/2+i*pi/4),t,r,c1,c2,c3)
        L=L,octogonep3c(z+2*r*cos(pi/8)*exp(i*k*pi/2),t,r,c1,c2,c3)
    return(L)

def octogone9p5c(z,t,r,c1,c2,c3,c4,c5):
    # local L,k,a
    r=float(r)
    L=seq[]
    a=r*sqrt(2)*sin(pi/8)
    L=L,octogonep5c(z,t,r,c1,c2,c3,c4,c5)
    for k in range(4):
        L=L,octogonep5c(z+(2*r*cos(pi/8)-a)*exp(k*i*pi/2+i*pi/4),t,r,c1,c2,c3,c4,c5)
        L=L,octogonep5c(z+2*r*cos(pi/8)*exp(i*k*pi/2),t,r,c1,c2,c3,c4,c5)
    return(L)

exe
axes=0;octogone9p3c(0,0,3,1,4,3) exe

axes=0;octogone9p3c(20,0,3,alea(200)+130,alea(200)+130,alea(200)+130) exe
axes=0;octogone9p5c(0,0,3,1,4,2,6,3) exe

axes=0;octogone9p5c(20,0,3,alea(10)+50,alea(10)+50,alea(10)+60,alea(10)+60,alea(10)+55) exe

3.4  La ronde des 37=4*9+1 octogones

axes=0;c1,c2,c3,c4,c5:=114,122,118,126,110; octogone9p5c(0,0,3,c1,c2,c3,c4,c5),octogone9p5c((3*4*cos(pi/8)-3*2*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3,c1,c2,c3,c4,c5)$(k=0..3),octogone9p5c(3*2*cos(pi/8)*exp(i*k*pi/2),0,3,c1,c2,c3,c4,c5)$(k=0..3) exe

4  Le pavage en couleur

On modifie la procédure octogonejux :

octogonep5cjux(z,t,r,p,q,c1,c2,c3,c4,c5):={
  local L,j,k;
  L:=NULL;
  r:=evalf(r);
  pour j de 0 jusque q-1 faire 
    pour k de 0 jusque p-1 faire 
      L:=L,octogonep5c(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r,c1,c2,c3,c4,c5);
    fpour;
  fpour;
  return L;
}:;

exeonload

def octogonep5cjux(z,t,r,p,q,c1,c2,c3,c4,c5):
    # local L,j,k
    L=[]
    r=float(r)
    for j in range(q):
        for k in range(p):
            L.append(octogonep5c(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r,c1,c2,c3,c4,c5))
    return(L)

exe
axes=0;octogonep5cjux(0,0,3,3,3,1,2,3,4,6) exe
On modifie la procédure medianes pour remplir le carré de la couleur c3 et pour tracer les médianes du carré en épaisseur 3 :

medianespc(z,t,r,p,q,c5):={
  local L,j,k,b,A;
  L:=NULL;
  r:=evalf(r);
  b:=r*sin(pi/8);
  pour j de 0 jusque q-2 faire 
    pour k de 0 jusque p-2 faire 
      A:=point(z+(r*cos(pi/8)+b)*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t));
      L:=L,affichage(carre(A+b*sqrt(2)*exp(i*t),A+i*b*sqrt(2)*exp(i*t)),c5+rempli);
      L:=L,affichage(segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t)),epaisseur_ligne_3);
      L:=L,affichage(segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t)),epaisseur_ligne_3);
    fpour;
  fpour;
  return L;
}:;

exeonload

def medianespc(z,t,r,p,q,c5):
    # local L,j,k,b,A
    L=[]
    r=float(r)
    b=r*sin(pi/8)
    for j in range(q-1):
        for k in range(p-1):
            A=point(z+(r*cos(pi/8)+b)*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t))
            L.append(affichage(carre(A+b*sqrt(2)*exp(i*t),A+i*b*sqrt(2)*exp(i*t)),c5+rempli))
            L.append(affichage(segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t)),epaisseur_ligne_3))
            L.append(affichage(segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t)),epaisseur_ligne_3))
    return(L)

exe
On modifie la procédure octogonepave :

octogonepave5c(z,t,r,p,q,c1,c2,c3,c4,c5):={
  local L;
  L:=NULL;
  L:=L,octogonep5cjux(z,t,r,p,q,c1,c2,c3,c4,c5);
  L:=L,medianespc(z,t,r,p,q,c5);
  return L;
}:;

exeonload

def octogonepave5c(z,t,r,p,q,c1,c2,c3,c4,c5):
    return octogonep5cjux(z,t,r,p,q,c1,c2,c3,c4,c5),medianespc(z,t,r,p,q,c5)

exe
axes=0;c1,c2,c3,c4,c5:=114,122,118,126,110;octogonepave5c(-17,pi/6,3,3,3,c1,c2,c3,c4,c5),octogonepave5c(0,0,3,3,3,c1,c2,c3,c4,c5),octogonepave5c(27,pi/3,3,3,3,c1,c2,c3,c4,c5);//c1,c2,c3,c4,c5:=alea(10)+130,alea(10)+150,alea(10)+130,alea(10)+50,alea(10)+210; exe

5  Les rosaces en couleur

5.1  la procédure rosaceocto

On modifie la procédure octogone :
Dans rosaceocto, on transforme les côtés du carré et de l’octogone en arcs de cercle.
Les paramètres sont z affixe du centre de l’octogone, t angle que fait une diagonale du caré avec l’axe des $x$, r le rayon du cercle circonscrit à l’octogone, 3 couleurs c1 pour les arcs de l’octogone et c2 pour les arcs du carré, c3 pour la couleur du fond (qui vaut par défaut 7) et u est l’angle au centre des arcs qui seront dessinés (qui vaut par défaut $3\frac{\pi}{8}$ (on peut choisir d’autres valeurs $\pi/2, \pi/3, \pi/4$) On utilise a comme variable locale pour désigner la moitié de la longueur de la diagonale du carré.
On tape :

rosaceocto(z,t,r,c1,c2,c3=7,u=3*pi/8):={
  local L,k,a;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  L:=L,affichage(cercle(z,r),c3+rempli);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3);
  pour k de 0 jusque 3 faire
    L:=L,affichage(segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)),epaisseur_ligne_3);
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),u,segment),c2+rempli);
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),-u,segment),c2+rempli);
  fpour;
  pour k de 0 jusque 7 faire 
    L:=L,affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),u,segment),c1+rempli);
    L:=L,affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),-u,segment),c1+rempli);
  fpour;
  return L;
}:;

exeonload
Syntaxe Python :

def rosaceocto(z,t,r,c1,c2,equal(c3,7),equal(u,3*pi/8)):
    # local L,k,a
    L=seq[]
    r=evalf(r)
    a=r*sqrt(2)*sin(pi/8)
    L.append(affichage(cercle(z,r),c3+rempli))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3))
    for k in range(4):
        L.append(affichage(segment(z+a*exp(i*k*pi/2+i*t),z+r*exp(i*k*pi/2+i*t)*cos(pi/8)),epaisseur_ligne_3))
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),u,segment),c2+rempli))
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),-u,segment),c2+rempli))
    for k in range(8):
        L.append(affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),u,segment),c1+rempli))
        L.append(affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),-u,segment),c1+rempli))
    return(L)

exe
axes=0;rosaceocto(0,0,5,126,118,6) exe

axes=0;c1,c2,c3:=120,125,7;rosaceocto(0,0,3,c1,c2,c3), rosaceocto((12*cos(pi/8)-6*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3,c1,c2,c3)$(k=0..3),rosaceocto(6*cos(pi/8)*exp(i*k*pi/2),0,3,c1,c2,c3)$(k=0..3) exe

5.2  la procédure rosaceoctogone

Dans rosaceoctogone, on transforme aussi les segments $PA$,$QC$,$RE$ et $SG$ en arcs de cercle.
On utilise comme variables locales a pour désigner la moitié de la longueur de la diagonale du carré et b pour désigner la moitié de la longueur du côté du carré

rosaceoctogone(z,t,r,c1,c2,c3=7,u=3*pi/8):={
  local L,k,a,b;
  L:=NULL;
  r:=evalf(r);
  a:=r*sqrt(2)*sin(pi/8);
  b:=r*sin(pi/8);
  L:=L,affichage(cercle(z,r),c3+rempli);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3);
  L:=L,affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3);
  pour k de 0 jusque 3 faire
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)+i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),-u/2,segment),c1+rempli);
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)-i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),+u/2,segment),c1+rempli);
    L:=L,affichage(triangle(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)+i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)-i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t)),c1+rempli);
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),u,segment),c2+rempli);
    L:=L,affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),-u,segment),c2+rempli);
  fpour;
  pour k de 0 jusque 7 faire 
    L:=L,affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),u,segment),c1+rempli);
    L:=L,affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),-u,segment),c1+rempli);
  fpour;
  return L;
}:;

exeonload
Syntaxe Python :

def rosaceoctogone(z,t,r,c1,c2,equal(c3,7),equal(u,3*pi/8)):
    # local L,k,a,b
    L=[]
    r=float(r)
    a=r*sqrt(2)*sin(pi/8)
    b=r*sin(pi/8)
    L.append(affichage(cercle(z,r),c3+rempli))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*pi/4+i*t),z-r*cos(pi/8)*exp(i*pi/4+i*t)),epaisseur_ligne_3))
    L.append(affichage(segment(z+r*cos(pi/8)*exp(i*3*pi/4+i*t),z-r*cos(pi/8)*exp(i*3*pi/4+i*t)),epaisseur_ligne_3))
    for k in range(4):
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)+i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),(-u)/2,segment),c1+rempli))
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)-i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),u/2,segment),c1+rempli))
        L.append(affichage(triangle(z+a*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)+i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t),z+(r*cos(pi/8)-i*b*(1/sin(u/2)-1/tan(u/2)))*exp(i*k*pi/2+i*t)),c1+rempli))
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),u,segment),c2+rempli))
        L.append(affichage(arc(z+a*exp(i*k*pi/2+i*t),z+a*exp(i*(k+1)*pi/2+i*t),-u,segment),c2+rempli))
    for k in range(8):
        L.append(affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),u,segment),c1+rempli))
        L.append(affichage(arc(z+r*exp(i*pi/8+i*k*pi/4+i*t),z+r*exp(i*pi/8+i*(k+1)*pi/4+i*t),-u,segment),c1+rempli))
    return(L)

exe
axes=0;rosaceoctogone(0,0,5,126,118,6) exe

axes=0;c1,c2,c3,c4,c5:=alea(20)+130,alea(20)+150,alea(20)+130,alea(20)+50,alea(20)+210;rosaceoctogone(0,0,3,c1,c2), rosaceoctogone((12*cos(pi/8)-6*sqrt(2)*sin(pi/8))*exp(i*pi/4+i*k*pi/2),0,3,c3,c4)$(k=0..3),rosaceoctogone(6*cos(pi/8)*exp(i*k*pi/2),0,3,c1,c5)$(k=0..3) exe

5.3  Le pavage avec les rosaces octogonales

On modifie la procédure octogonejux :

rosaceoctogonejux(z,t,r,p,q,c1,c2,c3=7,u=3*pi/8):={
  local L,j,k;
  L:=NULL;
  r:=evalf(r);
  pour j de 0 jusque q-1 faire 
    pour k de 0 jusque p-1 faire 
      L:=L,rosaceoctogone(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r,c1,c2,c3,u);
    fpour;
  fpour;
  return L;
}:;

exeonload

def rosaceoctogonejux(z,t,r,p,q,c1,c2,c3=7,u=3*pi/8):
    # local L,j,k;
    L=[]
    r=float(r)
    for j in range(q):
        for k in range(p):
             L.append(rosaceoctogone(z+2*r*cos(pi/8)*(k+i*j)*exp(i*t),t,r,c1,c2,c3,u))
    return L

exe
On utilise la procédure medianespc qui remplir le cercle circonscrit au carré de la couleur c3 et qui trace les médianes du carré en épaisseur 3 :

rosacemedianes(z,t,r,p,q,c3):={
  local L,j,k,b,A;
  L:=NULL;
  r:=evalf(r);
  b:=r*sin(pi/8);
  pour j de 0 jusque q-2 faire 
    pour k de 0 jusque p-2 faire 
      A:=point(z+(r*cos(pi/8)+r*sin(pi/8))*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t));
      L:=L,affichage(cercle(A,b*sqrt(2)),c3+rempli);
      L:=L,affichage(segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t)),epaisseur_ligne_3);
      L:=L,affichage(segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t)),epaisseur_ligne_3);
    fpour;
  fpour;
  return L;
}:;

exeonload
Syntaxe Python :

def rosacemedianes(z,t,r,p,q,c3):
    # local L,j,k,b,A
    L=[]
    r=float(r)
    b=r*sin(pi/8)
    for j in range(q-2+1):
        for k in range(p-2+1):
            A=point(z+(r*cos(pi/8)+r*sin(pi/8))*exp(i*pi/4+i*t)+2*r*cos(pi/8)*(k+i*j)*exp(i*t))
            L.append(affichage(cercle(A,b*sqrt(2)),c3+rempli))
            L.append(affichage(segment(A+b*exp(i*pi/4+i*t),A-b*exp(i*pi/4+i*t)),epaisseur_ligne_3))
            L.append(affichage(segment(A+b*exp(3*i*pi/4+i*t),A-b*exp(3*i*pi/4+i*t)),epaisseur_ligne_3))
    return(L)

exe
On modifie la procédure octogonepave :

rosaceoctogonepave(z,t,r,p,q,c1,c2,c3=7,u=3*pi/8):={
  local L;
  L:=NULL;
  L:=L,medianespc(z,t,r,p,q,c3);
  L:=L,rosaceoctogonejux(z,t,r,p,q,c1,c2,c3,u);
  return L;
}:;

exeonload
Syntaxe Python :

def rosaceoctogonepave(z,t,r,p,q,c1,c2,c3=7,u=3*pi/8):
    return medianespc(z,t,r,p,q,c3),rosaceoctogonejux(z,t,r,p,q,c1,c2,c3,u)

exe
axes=0;rosaceoctogonepave(0,0,3,3,3,4,4) exe
axes=0;rosaceoctogonepave(0,0,3,3,3,4,4,6) exe

Clone Clear + - ->   Restart Exec. all