Hélice fractale

[nnuuurrrrcc]

Bonjour à tous,
Je cherche à créer une représentation visuelle afin d'illustrer un concept. Difficile d'expliquer par écrit la forme que je cherche à créer mais je vais tenter de faire au mieux !

Imaginez une hélice circulaire. Celle ci s'enroule sur elle-même de manière hélicoïdale formant une nouvelle hélice qui, à nouveau, s'enroule sur elle même pour former une hélice et ainsi de suite. Il faut 9 "tours" de la première hélice pour former 1 tour de la deuxième hélice, plus grande. De la même manière, il faut 9 tours de la deuxième hélice pour former 1 tour de la troisième... et ainsi de suite.

Mon but serait de créer une visualisation 3d de cette forme, je suppose qu'un logiciel de tracage de fractales serait l'idéal, j'en ai trouvé de nombreux gratuits mais je n'ai pas les compétences pour traduire cette forme en formule fractale...

Si quelqu'un pouvait m'éclairer ce serait merveilleux !!!
Merci par avance

[Ben314]

Salut,
Avec n'importe quel langage de programmation acceptant la récursivité et ayant acces à un mode graphique, il ne devrait pas y avoir de problème.
Et, à mon avis, tu ira bien plus vite avec un langage "le plus basique possible" (style langage C) qu'avec les usines à gaz qu'on trouve un peu partout et où il te faudra des plombes pour trouver quelle est LA instruction dont tu as besoin parmi les milliers proposées . . .

[nnuuurrrrcc]

Je vais faire quelques recherches sur l'aspect programmation mais cela va nécessiter l'apprentissage d'un langage donc pas sur que j'aille plus vite
Merci pour ta réponse !

[Sokobania]

Pour ceux que ça intéresse, voici le code que j'ai posté sur l'autre forum.

Le code est du GéoTortue (qui me paraît plus simple que NetLogo).

Voici le code simplifié du paramétrage :

Code: Tout sélectionner

pour helix_setup nbs nbt xxL
  nbseg := nbs
  nbtours := nbt
  xL := xxL
 
  pitch := asin(xL/nbseg)
  alpha := 360 * nbtours / nbseg
  fractal_dim := log(nbseg) / log(xL)
 
  aff fractal_dim
fin


Par exemple, on peut faire:

Code: Tout sélectionner

helix_setup 9 1 4.0 // ou 3, comme Von Koch


Et le code simplifié de la fonction (en 4 lignes):

Code: Tout sélectionner

pour helix L age
  si (age == 0) alors [ av L ] sinon [
    pvb 90; rep nbseg [ pvh pitch; helix L/xL age-1; pvb pitch; td alpha]; pvh 90 ]
fin

que l'on peut appeler de la manière suivante:

Code: Tout sélectionner

vg; lc; tg 90; av 200; tg 90; av 200; td 180; bc; ct; helix 400 4; mt

Pour ceux qui ne lisent pas LOGO dans le texte, voici le code complet :

Code: Tout sélectionner

// Fonction pour définir les variables globales utiles
// en fonction de paramètres pertinents

// ----------
// Paramètres
// ----------
// nbseg   int : Nombre de petits segments par grand segment
// nbtours int : Nombre de tours par segment
// xL    float : Facteur d'homothétie entre un petit segment et un grand segment
 
pour helix_setup nbs nbt xxL
  // Nombre de petits segments par grand segment
  nbseg := nbs
 
  // Nombre de tours par segment
  nbtours := nbt
 
  // Facteur d'homothétie entre un petit segment et un grand segment
  xL := xxL
 
  // Constantes déduites
 
  // Inclinaison vers le haut
  // sin(pitch) == L / (nbseg * L / xL))
  pitch := asin(xL/nbseg)
 
  // Angle extérieur du polygone projeté (Rotation d'un segment à l'autre)
  alpha := 360 * nbtours / nbseg
 
  // Dimension fractale
  fractal_dim := log(nbseg) / log(xL)
 
  aff fractal_dim
fin
 
// helix_setup 9 1 4.0 // ou 3, comme Von Koch
 
// L procédure "helix" trace un segment hélicoïdal de longueur L
// avec un niveau de détail égal à age
 
pour helix L age
  // La tortue est en A, avec une orientation donnée.
  // Si <age> est nul, alors on trace juste le segment AB de longueur <L>
  // avec l'orientation courante de la tortue (en avançant de <L>).
  si (age == 0) alors [ av L ] sinon [
    // Sinon on remplace le segment AB de longueur <L> par une polyligne de <nbseg> segments
    // chacun de longueur <L>/<xL> et orientés en une hélice qui commence en A et finit en B.
    // La projection de cette polyligne sur le plan perpendiculaire à AB
    // est un polygone régulier <PP> à <nbseg> côtés
    // (faisant éventuellement plusieurs tours (comme une étoile à 5 branches))
    // La tortue se déplace donc sur un cylindre de base <PP> et de direction AB.
    // La développée de la trajectoire est un triangle A1 A2 B,
    // où A1 (resp. A2) est la position de A au départ (resp. à l'arrivée).
    // Ce triangle est rectangle en A2, de hauteur A2B = L.
    // La trajectoire de la tortue est l'hypothénuse A1B = nbseg * L / xL
    // L'angle A2A1B vérifie : sin(pitch) == L / (nbseg * L / xL))
 
    // D'abord, on commence par orienter la tortue dans le plan perpendiculaire à AB
    // avec un gros coup de tangage de 90° vers le bas (en pivotant vers le bas)
    pvb 90
 
    // Ensuite, pour dessiner l'hélice de A à B, on trace <nbseg> segments
    rep nbseg [
      // On met un petit coup de tangage pour que la tortue monte un peu de A vers B
      pvh pitch
      // On trace le petit segment qui n'est rien d'autre qu'une hélice réduite et plus jeune
      // (en suivant le principe d'une fractale)
      helix L/xL age-1
      // Arrivée au bout du petit segment, la tortue se remet dans le plan perpendiculaire
      // avec un petit coup de tangage inverse du précédent
      pvb pitch
      // On tourne la tortue de l'angle du polygone en restant dans le plan perpendiculaire
      td alpha]
    // Arrivée en B, la tortue qui est toujours dans le plan perpendiculaire à AB,
    // reprend l'orientation qu'elle avait en partant de A, c'est-à-dire parallèlement à AB
    // avec un gros coup de tangage de 90° vers le haut (en pivotant vers le haut)
    pvh 90 ]
fin

// vg; lc; tg 90; av 200; tg 90; av 200; td 180; bc; ct; helix 400 4; mt