Discussion :

[Jade Impériale]

Bonjour,

J'aimerais réaliser une spirale logarithmique dont les extrémités se rejoignent, et dont la ligne serait à certains endroits ondulée.

Merci pour vos réponses

[Linterne]

Réaliser avec quoi ?

Tu veux les équations ou la figure ?

Par exemple sous Matlab :

Code :

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

1
2
3
4
5
t = [0:0.01:(20*pi)];
w=[1:1:length(t)];
x = ((exp(0.1*t)).*(cos(t)));
y = ((exp(0.1*t)).*(sin(t)))+10*cos(0.5*w);
plot(x,y)

Tu peux jouer sur la fréquence et l'amplitude des oscillations pour avoir ce que tu veux exactement.

[Jade Impériale]

Merci pour ta réponse.

J'aimerai le réaliser avec Scilab.
Je voudrais les équations pour jouer avec la figure.
Sur ton dessin c'est top mais les ondulations suivent verticalement la spirale, j'aimerais quelles soient à plat et que la ligne àà un moment ne soit plus ondulée et puisse rejoindre le point de départ de la spirale.

[tbc92]

-- Pour la partie non ondulée.

pour i = 0 a 6*pi pas 0.01
r = 1+i
x = r * cos ( i+pi)
y = r * sin(i)
fin

Pour la même chose, mais ondulée, quelque chose comme ça :
pour i = 0 a 6*pi pas 0.01
r = (1+i)* ( 10 + sin (i*20) )/10
x = r * cos ( i+pi)
y = r * sin(i)
fin

Mais on ne veut pas que les 2 spirales soient jumelles, on veut passer de l'une à l'autre par une symétrie horizontale :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
pour i = 0 a 6*pi pas 0.01
   r = 1+i
   x = r * cos ( i+pi)
   y = r * sin(i)
fin
pour i = 6*pi à 0 pas -0.01
   r = (1+i)* ( 10 + sin (i*20) )/10
   x = r * cos ( i+pi)
   y = -r * sin(i)
fin

En s'inspirant du code fourni par Linterne, ma proposition reformulée pour Matlab doit pouvoir s'écrire :

Code matlab :

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

1
2
3
4
5
6
7
8
9
10
 
t = [0:0.01:(6*pi)];
x = ( 1+t).*cos (t+pi);
y = (1+t).*sin(t+pi); 
plot(x,y)
 
t = [0:0.01:(6*pi)];
x = ( 1+t).*(10+sin(t))./10*cos (t+pi);
y = -(1+t).*(10+sin(t))./10*sin(t+pi); 
plot(x,y)

[Linterne]

Oui, ou alors la traduction "mot à mot" de ton code

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
 
x=[];
y=[];
for i = 0:0.01:6*pi
   r = 1+i;
   x =[x r*cos(i+pi)];
   y =[y -r*sin(i)];
end
 
for i = 6*pi:-0.01:0
   r = (1+i)* ( 10 + sin (i*20) )/10;
   x =[x r*cos(i+pi)];
   y =[y r*sin(i)];
end
 
plot(x,y)

donne l image suivante :

[Jade Impériale]

Merci c'est presque cela.

J'aimerai qu'il y ai une boucle au centre (là où se rejoignent les ondulations très serrées et la ligne), que l'ondulation sur les bords extérieurs se métamorphose en ligne sans cassure brutale et sur les ondulations au centre soient plus serrées, est-ce possible je te prie ?

[wiwaxia]

Bonjour,

Voilà une question originale, qui conduit à des familles de courbes peu représentées.

La spirale de base doit vérifier une équation polaire du type r = R₀ * Exp(a * t) .
J'ai eu l'impression que les derniers codes proposés, dépourvus de termes exponentiels mais construits sur

Code :

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

r = 1+i;

conduisaient à une spirale d'Archimède, beaucoup moins évasée que la spirale logarithmique.
De plus, j'ai été surpris du maintien de termes tels que

Code :

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

cos(i+pi)]

que me serais attendu à voir remplacés par: -cos(i) .
Mais tout cela est secondaire, et facilement modifiable. Il y a des questions plus importantes concernant l'aspect de la courbe.

1°)

... j'aimerais ... que la ligne à un moment ne soit plus ondulée et puisse rejoindre le point de départ de la spirale.

Il suffit d'associer une seconde spirale à la précédente, symétrique par rapport à l'horizontale; ce qui a été fait.

2°)

... J'aimerais qu'il y ai une boucle au centre (là où se rejoignent les ondulations très serrées et la ligne) ...

Ce n'est pas possible avec la spirale logarithmique, qui s'enroule indéfiniment autour de son centre; mais on peut remplacer l'exponentielle par la fonction cosinus hyperbolique, qui présente en zéro un minimum non nul (d'où la boucle centrale), et adopte un comportement exponentiel aux grandes valeurs de son argument; on a en effet:
Cosh(0) = 1 et Cosh(u) ~ (1/2)*e^|u| quand |u| tend vers l'infini,
de sorte que la spirale obtenue présente au-delà d'un tour un aspect identique à la courbe initiale.
De plus, la parité de la fonction entraîne la réalisation la condition (1): ça tombe bien, on n'est plus obligé d'ajouter un autre graphe.

3°)

... J'aimerais que les ondulations au centre soient plus serrées, est-ce possible je te prie ?

Probablement non, en raison de la présence d'un nombre fini de pixels: le résultat sera décevant, sinon illisible.

4°)

... J'aimerais ... que l'ondulation sur les bords extérieurs se métamorphose en ligne sans cassure brutale ...

C'est théoriquement possible, mais au prix de corrections assez lourdes à coder - quelqu'un livrera peut-être une solution concise à cette demande. Ce que j'ai trouvé ne réalise pas rigoureusement le raccordement des tangentes, mais d'une manière approchée et sur un intervalle suffisamment court pour que la cassure passe inaperçue.

Ci-dessous les 2 graphes, avec et (à peu près) sans cassure; j'ai maintenu les 3 enroulements des courbes précédentes.



Toutes les fonctions du graphe - rayon (Rho), angle polaire (Theta), coordonnées relatives (F1x, F1y), couleur - dépendent d'une même variable réelle, dont les valeurs successives se répartissent uniformément sur le domaine [-1 ; +1] par une instruction donnée dans une autre partie du programme:

Code :

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

1
2
3
4
5
6
7
 
     FOR k:= -Lim TO Lim DO
       BEGIN
         t:= k / Lim;        x:= F_X(t); y:= F_Y(t);
         Xm:= Round(La * x); Ym:= Round(Ha * y);
         IF TxyMat(Xm, Ym) THEN Ma[Xm, Ym]:= C_P(t)          // Détermination de la couleur du pixel   
       END                                                   // TxyMat filtre les indices (Xm, Ym) vérifiant (0<Indice) et (Indice<=Dimension_Matrice)

Voici le coeur du programme, écrit en Virtual Pascal:

Code Pascal :

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
 
          // Alpha = ArcCosh(Kmax/K_Pi) = ArcCosh(15/(6*Pi)) = 0.180380080
          // Larg = th(Pi*Alpha/2) = 0.275993840
 
 CONST K_Pi = 6 * Pi;
       Kmax = 15;         R0 = 0.490 / Kmax; Larg = 0.276;
       Nosc = 100;        N_Pi = Nosc * D_Pi;
       Nosc2 = Sqr(Nosc); Lim1 = 1 / Nosc; Lim2 = 1.0 - Lim1;  
(*
 FUNCTION Rho(u: Reel): Reel;          // version courte - graphe avec cassure
   VAR p, q, r, Rspir, s, t, U2: Reel;
   BEGIN
     p:= ArcCosh(Kmax); q:= u * p; r:= Cosh(q); Rspir:= R0 * r;
     IF (u>0) THEN BEGIN
                     U2:= Sqr(u);  s:= Sin(N_Pi * U2);
                     t:= Larg * s; Rho:= Rspir * (1 + t)
                   END
              ELSE Rho:= Rspir
   END;                                      *)
 
 FUNCTION Rho(u: Reel): Reel;
   VAR p, q, r, Rspir, s, t, U2: Reel;
   BEGIN
     p:= ArcCosh(Kmax); q:= u * p; r:= Cosh(q); Rspir:= R0 * r;
     IF (u>0) THEN BEGIN
                     U2:= Sqr(u); s:= Sin(N_Pi * U2);
                     IF (U2<Lim2) THEN t:= Larg * s
                                  ELSE BEGIN
                                         p:= Sqr(U2 - Lim2); q:= Nosc2 * p;
                                         p:= Larg * (1 - q); t:= p * s
                                       END;
                     Rho:= Rspir * (1 + t)
                   END
              ELSE Rho:= Rspir
  END;
 
 FUNCTION Theta(u: Reel): Reel;
   VAR p, q, r, s: Reel;
   BEGIN
     Theta:= K_Pi * u
   END;
 
 FUNCTION F1x(t: Reel): Reel;          // 0 <= F1x <= 1
   VAR p, q, r, Th: Reel;
   BEGIN
     r:= Rho(t); Th:= Theta(t); q:= Cos(Th);
     p:= r * q;  F1x:= p + 0.38
   END;
 
 FUNCTION F1y(t: Reel): Reel;          // 0 <= F1y <= 1
   VAR p, q, r, Th: Reel;
   BEGIN
     r:= Rho(t); Th:= Theta(t); q:= Sin(Th);
     p:= r * q;  F1y:= p + 0.5
   END;

En commentaires la version courte de la fonction Rho(t) correspondant au premier graphe; la 4^me ligne de constantes est alors inutile.
Le bloc de 3 lignes de constantes a été sorti de la fonction concernée (Rho(t)) afin d'abréger le temps d'exécution; cette accumulation relativement lourde de calculs préliminaires vient de l'emploi d'une fonction hyperbolique.
Ce programme assez fruste doit être remanié, parce que moulé faute de temps dans une structure préexistante.

Les habitués de Matlab traduiront facilement ce code écrit en Pascal.