Discussion :

[nnuuurrrrcc]

Bonjour à tous,
Je cherche à créer une représentation visuelle afin d'illustrer un concept mathématique. 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. J'ai d'abord supposé qu'un logiciel de traçage de fractales 3d 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 et souvent les ensembles proposés sont beaucoup plus complexes que ce que je recherche.

On m'a orienté vers la programmation en me disant que ce serait plus simple de créer ma forme avec un langage de type C ou javascript, cependant je n'ai qu'une connaissance très limitée de la programmation...

Plusieurs questions se posent donc à moi :
Existe-t-il déjà des outils en ligne permettant de réaliser des motifs récurrents en 3d? (j'en ai trouvé mais seulement en 2d...)
Si je devais le faire moi-même, quel serait le degré de complexité d'une telle réalisation ?
Quel langage serait le plus adapté et le plus abordable?


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

[Guesset]

Bonjour,

Déjà il faudrait l'exprimer sous une forme un tant soit peu mathématiques ou un griffonnage. Que signifie "Celle ci s'enroule sur elle-même de manière hélicoïdale"? C'est le propre (et l'origine du nom) d'une hélice que de tracer une hélicoïdale en progressant. Que signifie "9 "tours" de la première hélice pour former 1 tour de la deuxième hélice"? Le rapport 9 correspond à quoi ? Une logique d'engrenage ? Un facteur de taille ?

Peut être est-ce plus clair pour quelqu'un d'autre...

Salutations

[jack-ft]

C'est vrai que ce n'est pas complètement clair...

Voici ce que je pense comprendre...

Imaginez une hélice circulaire.

J'imagine que tu penses à un point qui se déplace en combinant 2 mouvements:
- il tourne à une distance constante R1 autour d'un axe (par exemple vertical)
- il se translate à vitesse constante V1 parallèlement à l'axe

Ce déplacement crée une courbe d'épaisseur nulle en forme d'hélice circulaire (une loxodromie du cylindre vertical de rayon R1)

On peut aussi se le représenter en prenant un fil (très fin) qu'on enroule autour d'un cylindre tout en le décalant progressivement le long du cylindre.

Un peu comme le fil des anciens téléphones du siècle précédent... (si ce fil était plus mince)

Celle ci s'enroule sur elle-même de manière hélicoïdale formant une nouvelle hélice

2 manières de voir la chose (qui, au final, sont équivalentes):

1. Du plus petit vers le plus grand:
   On prend le pied de la table sur laquelle est posé le téléphone.
   Il se trouve que ce pied est de section circulaire, c'est donc un cylindre.
   On enroule le fil du téléphone qui est une hélice autour de ce pied, de nouveau en combinant l'enroulement autour du pied cylindrique avec le décalage progressif le long du pied.
   On obtient alors une nouvelle hélice plus grande dont le "fil" n'est pas une courbe d'épaisseur nulle, mais une hélice plus petite (peut-être d'un facteur 9...).
   
   
2. Du plus grand vers le plus petit
   On considère l'hélice de niveau 1 comme étant "l'axe" d'une nouvelle hélice (plus petite):
   pour cela, on fait tourner un point non plus autour d'un axe rectiligne, mais autour de l'hélice de niveau 1, de nouveau en combinant la rotation autour l'hélice de niveau 1 avec le décalage progressif le long de cette 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.

Cette description semble correspondre à ma 1ère description (du plus petit vers le plus grand)

Lorsque le fil téléphonique a fait un tour autour du pied (avec un décalage vertical), on compte 9 spires du fil téléphonique.

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.

Ça me paraît clair.

Mon but serait de créer une visualisation 3d de cette forme. J'ai d'abord supposé qu'un logiciel de traçage de fractales 3d 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 et souvent les ensembles proposés sont beaucoup plus complexes que ce que je recherche.

On m'a orienté vers la programmation en me disant que ce serait plus simple de créer ma forme avec un langage de type C ou javascript, cependant je n'ai qu'une connaissance très limitée de la programmation...

Plusieurs questions se posent donc à moi :
Existe-t-il déjà des outils en ligne permettant de réaliser des motifs récurrents en 3d? (j'en ai trouvé mais seulement en 2d...)
Si je devais le faire moi-même, quel serait le degré de complexité d'une telle réalisation ?
Quel langage serait le plus adapté et le plus abordable?

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

Il faudrait trouver la formule mathématique de cette courbe...

En coordonnées cartésiennes, pour la spirale de niveau 1, autour d'un axe vertical, c'est assez simple:
x = R1 cos t
y = R1 sin t
z = V1 t

Maintenant, pour faire la spirale de niveau 2 autour de la spirale de niveau 1 (du plus grand au plus petite), c'est une autre paire de manches.

La géométrie tortue, associée au langage LOGO, est extrêmement bien adaptée pour les fractales... à base de segments, comme le flocon de Von Koch, qui s'écrit en quelques lignes, mais, pour une "courbe plus courbe", c'est coton...

Peut-être en demandant sur maths-forum : https://www.maths-forum.com/cafe-mat...e-t281220.html

[nnuuurrrrcc]

Oui effectivement c'est ca jack, ton image du fil téléphonique qu'on enroule autour du pied de la table représente bien ce que j'essayais d'expliquer. L'idée serait de pouvoir créer de la récurrence comme si on enroulait à son tour le pied de table autour d'un cyclindre plus grand, un tronc d'arbre par exemple.
Le rapport 9 est un coefficient entre les pas des hélices. Si a1 est le pas de la petite hélice (le fil du téléphone) et a2 le pas de la grande (le pied de table), on a a2=9a1. Si a3 est le pas de la 3 (l'arbre) on a a3 =9a2.

Effectivement pour tracer l'hélice 1 pas de souci, les coordonnées cartésiennes permettent de la modéliser aisément et j'applique un facteur -1 sur y pour qu'elle tourne dans le sens horaire. Mais je bloque pour créer l'helice 2 et créer la récurrence.

Le post de ton lien vers maths forum est le miens, j'y ai posé ma question mais on m'a renvoyé vers la programmation qui serait à priori plus simple pour modéliser mon idée.

Si seulement je pouvais traduire ce concept sous la forme d'une formule fractale type z^2 + c (mandlebrot) je pourrais obtenir une visualisation avec un nombre colossal d'itérations. Mais si ce n'est pas possible je pourrais me contenter de 3 ou 4 itération mais pour cela il me faut deja parvenir à passer de l'helice 1 à l'hélice 2.

Merci à vous deux d'avoir pris le temps d'essayer de comprendre en tout cas

[tbc92]

Bien vu l'image du fil téléphonique autour du pied de table. C'était à peu près clair que c'était ça, mais trouver l'image pour mettre tout le monde d'accord, bravo.

Il y a un paramètre qui semble manquer avant de faire le dessin, c'est le diamètre du pied de la table.
Le fil téléphonique, on le voit, on sait qu'il tourne sur un cylindre de diamètre un peu plus grand qu'un centimètre. Mais la forme obtenue sera très différente, selon que le pied de table a un diamètre de 2cm ou de 10cm.

Ensuite, il y a la programmation. Et surtout, il y a plein de maths.
Prenons un fil imaginaire, au centre de mon fil téléphonique. Ce fil imaginaire décrit donc une hélice autour du pied de la table.
En chaque point de ce fil imaginaire,
1) il faut calculer la direction de ce fil imaginaire,
2) il faut calculer l'équation du plan perpendiculaire à cette direction, (produits vectoriels ...)
3) il faut 'orienter' correctement ce plan. Je mets le mot 'orienter' entre guillemets, parce qu'il faudrait 10 lignes pour détailler !
4) il faut trouver le point de ce plan où se trouve notre fil téléphonique.

4 calculs, 4 exercices mathématiques, et chacun de ces 4 exercices est complexe et fastidieux. En particulier le point 3.
Si on sait faire ces exercices mathématiques, la traduction en n'importe quel langage est relativement simple.

Et ensuite, faire ça de façon suffisamment propre, pour pouvoir faire de la récursivité... pffffffff !

[mach1974]

Il faut reprendre les formules des rubans de moebius .
http://serge.mehl.free.fr/anx/equ_ru...C3%A9gl%C3%A9e.
j'imagine aussi qu'il y a une problématique de trainée , qu'il faut calculer avec Navier stokes?
https://en.wikibooks.org/wiki/Parall...okes_Equations

[jack-ft]

Bien vu l'image du fil téléphonique autour du pied de table. C'était à peu près clair que c'était ça, mais trouver l'image pour mettre tout le monde d'accord, bravo.

Oui ! Je suis assez "visuel" et j'aime bien les images qui permettent de se faire une idée de la chose.

D'ailleurs, il se pourrait bien que le pied de table soit en fait une frite de piscine... que l'on peut enrouler en hélice sur elle-même...

La géométrie tortue, associée au langage LOGO, est extrêmement bien adaptée pour les fractales... à base de segments, comme le flocon de Von Koch, qui s'écrit en quelques lignes, mais, pour une "courbe plus courbe", c'est coton...

En fait, ça s'écrit bien en 5 lignes de LOGO 3D, d'une manière très semblable au flocon de Von Koch, à condition de se contenter de spires en forme de nonagone régulier.

Il faut juste le bon moteur LOGO avec les bons opérateurs, notamment pour gérer les angles de Cardan (lacet, tangage, roulis).
Tous les LOGOs (2D ou 3D) gèrent le lacet (avec gauche (ou tg) et droite (ou td)), mais pour le tangage en 3D, c'est pas évident de trouver le bon LOGO... (le roulis ne sert pas)

[jack-ft]

Finalement, j'ai utilisé GéoTortue (qui me paraît plus simple que NetLogo).

Voici le code simplifié du paramétrage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Et le code simplifié de la fonction (en 4 lignes (et non 5, comme annoncé précédemment)):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
// 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 à <nbseg> côtés
    // (faisant éventuellement plusieurs tours (comme une étoile à 5 branches))
 
    // 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

[nnuuurrrrcc]

Wow bravo et immense merci ! Je vais essayer de rentrer ce code dans Geotortue afin d'obtenir la visualisation de ton image puis faire varier les paramètres !! Encore un grand merci !!

[jack-ft]

Hello nnuuurrrrcc !

As-tu pu tester ?

Et, le cas échéant, obtenir des résultats intéressants ?

[jack-ft]

Finalement, je me suis offert une petite formation NetLogo grâce à laquelle j'ai pu faire un modèle basique qui m'a servi de moule pour tester quelques fractales, comme un flocon de Von Koch ou un triangle de Sierpiński, et même une hélice... Une fois le modèle basique mis au point, la conversion géotortue -> NetLogo fut très simple.

Netlogo permet de manipuler la perspective du résultat obtenu (orbit, zoom, move), mais ne semble pas permettre d'exporter la vue 3D en elle-même... afin de la visualiser en 3D dans un outil VRML autre que NetLogo. Du coup, j'ai choisi d'ajouter quelques fonctions afin de pouvoir générer un fichier ".wrl" lisible par view3Dscene.app (ou freewrl.app par exemple). Comme je ne sais pas s'il est possible d'écrire des wrappers autour des fonctions de déplacement des tortues, les fonctions d'enregistrement des points de passage de la tortue (ou des tortues) que j'ai ajoutées doivent être appelées à la main à la discrétion du programmeur. Dans le cas d'une courbe fractale ne comprenant qu'une seule instruction de déplacement de la tortue, c'était particulièrement simple.

Pour ceux que ça intéresse, voici un exemple de fichier .wrl que j'ai généré. Comme developpez.net ne connait pas l'extension ".wrl", je l'ai remplacée par ".wrl.txt" (après tout, c'est un fichier texte); donc, pour le visualiser, il faut remplacer ".wrl.txt" par ".wrl".

helix-fractal.wrl.txt

Bon, manifestement, il reste un petit bug...