Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

#1 12-07-2014 13:53:10

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Cardioides et limaçons

Bonjour,



J'ai découvert dans un livre une figure qui m'a très vite semblé intéressante, la cardioïde



cardioïde

Au passage, cette courbe est un cas particulier d'un limaçon de Pascal
limaçons



J'ai essayé de trouver une équation paramétrée me permettant de tracer cette figure grâce à un module de plot 2D
cardioïde



Voici la démarche



Soit [tex]Cercle[/tex] un cercle de rayon [tex]R=1[/tex] de centre le point [tex]A(0; 0)[/tex]
Soit le point [tex]B[/tex] tel que  [tex]B \in Cercle[/tex]. C'est un point fixe et c'est "l'origine" de la cardioïde
Soit le point [tex]C[/tex] tel que  [tex]C \in Cercle[/tex]. C'est un point mobile
Soit [tex]I[/tex] le point à l'intersection de la tangente [tex](\Delta)[/tex] au point [tex]C[/tex] et de la droite passant par [tex]B[/tex] perpendiculaire à [tex](\Delta)[/tex], que l'on nomme [tex](D')[/tex]
Soit [tex](BI)[/tex] la droite modélisée par une fonction affine : [tex]f(x)=xtan\alpha+R[/tex]

Le point [tex]C[/tex] a pour coordonnées [tex](R cos \alpha; R sin \alpha)[/tex]



Nous cherchons à déterminer la position du point [tex]I[/tex] en fonction des fonctions trigonométriques qui s'appliquent à l'angle [tex]\alpha[/tex].



Soit [tex]M[/tex] un point tel que [tex]M \in (\Delta)[/tex] et de coordonnées [tex](x, y)[/tex]

On a
[tex]\overrightarrow{AC}(Rcos\alpha; Rsin\alpha)[/tex]

Or
[tex]\overrightarrow{AC}\perp\overrightarrow{CM}[/tex]

D'où un produit scalaire égal à zéro
[tex]Rsin\alpha(x-Rcos\alpha)-Rcos\alpha(y-Rsin\alpha)=0[/tex]

En isolant [tex]x[/tex], on obtient
[tex]x = cos\alpha(1-Rsin\alpha)[/tex]

On substitue [tex]x[/tex] l'équation de la droite [tex](D')[/tex]:
[tex](D'): xtan\alpha+R[/tex] d'où [tex]y = sin\alpha(1-Rsin\alpha)+R[/tex]

Bingo ! Un point [tex]I[/tex] appartenant à une cardioïde a pour coordonnées [tex]I( cos\alpha(1-Rsin\alpha); sin\alpha(1-Rsin\alpha)+R)[/tex]


Le programme utilise les fonctions du module [tex]turtle[/tex]

def cardioide(rayon):
    alpha = 0
    while alpha <= 2*pi:
        x = rayon*cos(alpha)*(1-cos(alpha))
        y = rayon*sin(alpha)*(1-cos(alpha))
        goto(x, y)
        alpha += 0.001

Le résultat
cardioïde


Désireux de faire quelques expérimentations, je suis parti non pas d'un cercle mais d'une ellipse...

Je me suis lancé, j'ai obtenu la formule suivante

[tex]x = R\Big(cos^2\alpha - \frac{sin\alpha}{2}+ \frac{sin^2\alpha}{4}\Big)\Big(\frac{1}{cos\alpha + \frac{sin^2\alpha}{4cos\alpha}}\Big) [/tex]
et [tex]y = x \frac{tan\alpha}{2} + R[/tex]

Je vous assure que j'ai développé ou factorisé lorsqu'il était judicieux de le faire, en utilisant les propriétés vues en troisième sur les fonctions trigonométriques pour simplifier les calculs , ...



Je n'ai pas eu le courage de calculer [tex]y = x \frac{tan\alpha}{2} + R[/tex]... Je ne voyais pas l'intérêt de le faire avec l'expression de [tex]x[/tex] aussi compliquée ...

def courbe(r):
    alpha = 0
    while alpha <= 2*pi:
        x = r*((cos(alpha)**2) - (sin(alpha)/2) + ((sin(alpha)**2)/4))*(1/(cos(alpha) + ((sin(alpha)**2)/ (4*cos(alpha)))))
        y = x*(tan(alpha)/2) + r
        goto(x, y)
        alpha += 0.001

(!!!)

Ce n'était pas le résultat attendu. Finalement, en jetant de nouveau un coup d’œil aux calculs et croquis, j'ai vu que le problème était mal posé dès le départ, dans les croquis. Voici la figure à la base de l'erreur reproduite avec Geogebra ...

courbe_Geogebra.png

Cette courbe n'est donc ni une cardioïde, ni un limaçon de Pascal ; d'une part car l'on ne part pas d'un cercle, et d'autre part car la droite [tex](EG)[/tex] est perpendiculaire à la droite [tex](FE)[/tex]. En outre, [tex]D[/tex] n'est pas un point de l'ellipse, ce qui est à l'origine de cette "goutte" partageant un point avec l'ellipse... La courbe a donc la même propriété que la cardioïde : elle est belle, esthétique.


Si vous pouviez m'aider à simplifier l'équation paramétrée de la courbe obtenue ,

[tex]x = R\Big(cos^2\alpha - \frac{sin\alpha}{2}+ \frac{sin^2\alpha}{4}\Big)\Big(\frac{1}{cos\alpha + \frac{sin^2\alpha}{4cos\alpha}}\Big) [/tex]
et [tex]y = x \frac{tan\alpha}{2} + R[/tex], je vous serai reconnaissant


Merci, et bonne journée !

Dernière modification par lambda (25-08-2014 11:37:59)

Hors ligne

#2 13-07-2014 17:52:12

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Re : Cardioides et limaçons

Bonjour,

J'ai "simplifié" l'équation paramétrée finalement, ce fut long ...

[tex]x = -cos\alpha\times(2sin\alpha-3cos^2\alpha-1)\frac{R}{3cos^2\alpha+1} [/tex]

et

[tex]y = -\frac{Rcos\alpha\times tan\alpha(-3cos^2\alpha+2sin\alpha-1)}{2(3\times cos^2\alpha+1)}+R[/tex]

Je me suis orienté vers un logiciel de modélisation/visualisation 3D afin de tracer des courbes, j'en ai vu un autre mais assez compliqué (là)... Je vous partage le programme

from math import cos, sin, tan, pi
import bpy

"""
Programme qui trace sur
le plan un nuage de points
appartenant à une courbe
"""

def curve(radius):
    verts = []  # la liste des points de la courbe
    faces = []  # la liste des faces de la courbe (vide)
    alpha = 0   # angle en radians

    while alpha <= 2*pi:    # tour de cercle
   
        # fonction parametrée, en coordonnées cartésiennes
        x = radius*((cos(alpha)**2) - (sin(alpha)/2) + ((sin(alpha)**2)/4))*(1/(cos(alpha) + ((sin(alpha)**2)/ (4*cos(alpha)))))
        y = x*(tan(alpha)/2) + radius
        z = 0.0 # la courbe est tracée sur le plan
       
        vertex = (x, y, z)
        verts.append(vertex)  # on ajoute les coordonnées  du point dans la liste
       
        alpha += 0.01   # on augmente l'angle alpha de 0, 01 radians
   
    mesh = bpy.data.meshes.new('curve')  # on crée le maillage
    object = bpy.data.objects.new('curve', mesh) # on crée l'objet
   
    # on donne la position de l'objet dans l'espace
    object.location = (0, 0, 0)
    bpy.context.scene.objects.link(object)

    # à partir des données on affiche les points
    mesh.from_pydata(verts,[],faces)
    mesh.update(calc_edges=True)

curve(30)    # on crée une courbe de rayon 30 (unité arbitraire)

Maintenant, je cherche à faire pivoter sur un axe la courbe afin de former une sorte de sphère... Je me suis initié aux coordonnées sphériques mais vu la complexité du problème, j'aimerais avoir votre avis concernant la démarche à suivre pour parvenir à mes fins.

Votre aide est d'avance, très appréciée !

Salut.

Dernière modification par lambda (25-08-2014 11:40:54)

Hors ligne

#3 14-07-2014 14:40:22

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Re : Cardioides et limaçons

Bonjour,

EURÈKA !
Ce qui semblait impossible est devenu réalité !

À force de persévérer, j'ai réussi à résoudre mon problème. Le code est de mon cru.
Mon programme consiste à tracer la courbe que j'avais découverte accidentellement puis de la faire pivoter sur un axe. L'ensemble de ces points dans l'espace peut alors être considéré comme un volume. Pour cela j'ai cherché du côté des matrices de rotation sur le plan, puis dans l'espace...

Ce qui est particulier c'est que ce volume possède une surface qui se rentre dedans, ce qui est très curieux...

courbe.png

from math import cos, sin, tan, pi
import bpy  #  module du logiciel




##################################

#  Programme qui trace sur le plan

#  un nuage de points appartenant

#  à la surface d'un volume

##################################




def matriceRotation( alpha ):
    """
    Construction de la
    matrice de rotation
    alpha: angle (en degré)
    """
   
    f = lambda angle : angle / 180. * pi
    #  on crée une fonction de conversion degrés => radians
   
    a = f( alpha )
    #  conversion de l'angle en radians
   
    return [ [ cos( a ), 0, - sin( a ) ], [ 0, 1, 0 ], [ sin( a ), 0, cos( a ) ] ]
    #  on renvoie la matrice de rotation sur l'axe y




def produitMatriceVec( A, V ):
    """
    Produit matriciel
    V : vecteur
    A : matrice
    """
   
    dimV = len( V )
    #  dimension du vecteur d'entrée
   
    dimV2 = len( A )
    #  dimension du vecteur de sortie
   
    V2 = []
    #  vecteur de sortie
   
    for k in range( dimV2 ):
       
        acc = 0.
       
        for j in range( dimV ):
           
            acc = A[k][j] * V[j] + acc
            #  produit matriciel
           
        V2.append( acc )
       
    return V2
    #  vecteur résultant du produit matrice-vecteur




def donneesCourbe( rayon, n=.01 ):
    """
    Calcul des coordonnées
    des points de la courbe
    """
   
    pointsCourbe = []
    #  la liste des points de la courbe
   
    alpha = 0
    #  angle en radians
   
    while alpha <= 2*pi:
    #  calcul des coordonnées des points de la courbe
   
        x = ( - cos( alpha ) * ( 2 * sin( alpha ) - 3 * cos( alpha ) ** 2 - 1 ) * rayon / ( 3 * cos( alpha ) ** 2 + 1 ) )
        y = ( x * ( tan( alpha ) / 2 ) + rayon )
        z = 0.
        #  fonction paramétrée, en coordonnées cartésiennes
       
        point = ( x, y, z )
        #  on conserve temporairement les coordonnées du point
       
        pointsCourbe.append(  point  )
        #  on ajoute les coordonnées du point dans la liste
       
        alpha += n
        #  on augmente l'angle alpha de n radians
       
    return pointsCourbe
    #  on renvoie la liste des coordonnées des points de la courbe




def donneesVolume( pointsCourbe, n=5 ):
    """
    Calcul des coordonnées
    des points du volume
    par rotation de la
    courbe sur l'axe y
    """
   
    pointsVolume = []
    #  liste des points sur la surface du volume
   
    for k in range( len( pointsCourbe ) ):
    #  Création du volume par rotation de la courbe sur l'axe y
   
        theta = 0
        #  angle en degré
       
        while theta <= 180.:
        #  demi-cercle
       
            A = matriceRotation( theta )
            #  création de la nouvelle matrice de rotation d'angle theta
           
            pointsVolume.append( produitMatriceVec( A, pointsCourbe[k] ) )
            #  ajout des nouveaux points résultant de la rotation des points initiaux
           
            theta += n
            #  on augmente theta de n degrés
           
    return pointsVolume




def constructionVolume( nomObjet, points ):
    """
    Construction de la
    courbe dans l'espace
    """
   
    faces = []
    #  la liste des faces (vide)
   
    maillage = bpy.data.meshes.new( nomObjet )
    #  on crée le maillage
   
    objet = bpy.data.objects.new( nomObjet, maillage )
    #  on crée l'objet
   
    objet.location = ( 0, 0, 0 )
    bpy.context.scene.objects.link( objet )
    #  on donne la position de l'objet dans l'espace
   
    maillage.from_pydata( points, [], faces )
    maillage.update( calc_edges=True )
    #  à partir des données on affiche les points
   




nuagePoints = donneesVolume( donneesCourbe( 30. ) )
constructionVolume( 'Volume', nuagePoints )
#  on exécute


Salut.

Dernière modification par lambda (15-11-2014 20:47:04)

Hors ligne

#4 14-07-2014 18:04:06

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : Cardioides et limaçons

Salut,

C'est bien, bravo !
Petite remarque : j'aimerais bien que tu t'abstiennes de poster des draps de lit en guise d'image.
image n° 1 : 1618 x 906 pixels soit avec une résolution (raisonnable celle-là) de 72 points par pouce, 57,08 cm x 31,06 cm...

Et il n'y en a pas qu'une, mais 3... !!!
A l'avenir, je te serai reconnaissant de ne plus monopoliser la bande passante quand on ouvre ta discussion : réduis la taille de tes images, concentre-toi sur l'essentiel.

Merci d'avance.

      Yoshi
- Modérateur -


Arx Tarpeia Capitoli proxima...

Hors ligne

#5 14-07-2014 18:23:40

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Re : Cardioides et limaçons

Bonjour Yoshi,

C'est réglé ;)

Hors ligne

#6 14-07-2014 18:48:17

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : Cardioides et limaçons

Re,

Non, rien n'est réglé : il reste 2 draps de lit au lieu de 3.
Se concentrer sur l'essentiel signifie ceci :

]140714075331441650.jpg

J'ai revu contraste et densité des couleurs et recadré ton drap de lit n°1 : cette image ne fait que 605 x 645 pixels et pourtant elle est bien plus "visible" que la tienne...
Cherchez l'erreur !

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#7 14-07-2014 19:17:08

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Re : Cardioides et limaçons

Salut,

Tu as bien raison. C'est bien plus efficace.
Je corrige tout de suite et garde cette habitude.

Ayant posté une portion du volume par soucis de lisibilité, je vous partage la figure sous forme de nuage de points
fig.png
Je compte reconstituer sa surface, mais cela, c'est pour plus tard...

Dernière modification par lambda (18-07-2014 19:14:29)

Hors ligne

#8 18-07-2014 13:56:35

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Re : Cardioides et limaçons

Bonjour,

J'ai essayé de créer une petite interface utilisateur, bien visuelle, pour tester la fonction en variant ses paramètres. Si si !

Le logiciel utilisé est par là. Afin de lancer le programme, il vous faut ouvrir l'éditeur de texte incorporé, y insérer le code, puis le lancer via le bouton 'run script'. L'interface utilisateur du programme est visible sur le paneau de gauche et permet de tester le programme de façon interactive.


from math import cos, sin, tan, pi
#  module maths

import bpy
#  module du logiciel

from bpy.props import *
#  module pour l'interface utilisateur




#  Programme qui trace sur le plan un nuage de

#  points appartenant à une courbe puis la fait

#  pivoter sur un axe afin d'engendrer un volume




def matriceRotation( alpha ):
    """
    Construction de la
    matrice de rotation
    alpha: angle (en degré)
    """
   
    f = lambda angle : angle / 180. * pi
    #  on crée une fonction de conversion degrés => radians
   
    a = f( alpha )
    #  conversion de l'angle en radians
   
    return [ [ cos( a ), 0, - sin( a ) ], [ 0, 1, 0 ], [ sin( a ), 0, cos( a ) ] ]
    #  on renvoie la matrice de rotation sur l'axe y




def produitMatriceVec( A, V ):
    """
    Produit matriciel
    V : vecteur
    A : matrice
    """
   
    dimV = len( V )
    #  dimension du vecteur d'entrée
   
    dimV2 = len( A )
    #  dimension du vecteur de sortie
   
    V2 = []
    #  vecteur de sortie
   
    for k in range( dimV2 ):
       
        acc = 0.
       
        for j in range( dimV ):
           
            acc = A[k][j] * V[j] + acc
            #  produit matriciel
           
        V2.append( acc )
       
    return V2
    #  vecteur résultant du produit matrice-vecteur




def donneesCourbe( rayon, n ):
    """
    Calcul des coordonnées
    des points de la courbe
    """
   
    pointsCourbe = []
    #  la liste des points de la courbe
   
    alpha = 0
    #  angle en radians
   
    while alpha <= 2*pi:
    #  calcul des coordonnées des points de la courbe
   
        x = ( - cos( alpha ) * ( 2 * sin( alpha ) - 3 * cos( alpha ) ** 2 - 1 ) * rayon / ( 3 * cos( alpha ) ** 2 + 1 ) )
        y = ( x * ( tan( alpha ) / 2 ) + rayon )
        z = 0.
        #  fonction paramétrée, en coordonnées cartésiennes
       
        point = ( x, y, z )
        #  on conserve temporairement les coordonnées du point
       
        pointsCourbe.append(  point  )
        #  on ajoute les coordonnées du point dans la liste
       
        alpha += n
        #  on augmente l'angle alpha de n radians
       
    return pointsCourbe
    #  on renvoie la liste des coordonnées des points de la courbe




def donneesVolume( pointsCourbe, n ):
    """
    Calcul des coordonnées
    des points du volume
    par rotation de la
    courbe sur l'axe y
    """
   
    pointsVolume = []
    #  liste des points sur la surface du volume
   
    theta = 0
    #  angle en degré
       
    while theta <= 180.:
    #  demi-cercle
       
        for k in range( len( pointsCourbe ) ):
        #  Création du volume par rotation de la courbe sur l'axe y
   
            M = matriceRotation( theta )
            #  création de la nouvelle matrice de rotation d'angle theta
           
            pointsVolume.append( produitMatriceVec( M, pointsCourbe[k] ) )
            #  ajout des nouveaux points résultant de la rotation des points initiaux
           
        theta += n
        #  on augmente theta de n degrés
       
    return pointsVolume




def constructionVolume( context, nomObjet, points ):
    """
    Construction de la
    courbe dans l'espace
    """
   
    faces = []
    #  la liste des faces (vide)
   
    segments = []
    #  la liste des segments
       
    maillage = bpy.data.meshes.new( nomObjet )
    #  on crée le maillage
   
    objet = bpy.data.objects.new( nomObjet, maillage )
    #  on crée l'objet
   
    objet.location = ( 0, 0, 0 )
    context.scene.objects.link( objet )
    context.scene.objects.active = objet
    #  on donne la position de l'objet dans l'espace
   
    maillage.from_pydata( points, segments, faces )
    maillage.update( calc_edges=True )
    #  à partir des données on affiche les points
   
    return objet




def ajouteVolume( context, rayon, alpha, theta ):
   
    points = donneesVolume( donneesCourbe( rayon, alpha ), theta )
    return constructionVolume( context, "Volume", points )




#  Interface utilisateur visuelle




class MESH_OT_primitive_volume_add( bpy.types.Operator ):
    """
    Ajoutons un volume
    """
   
    bl_idname = "mesh.primitive_volume_add"
    bl_label = "Volume"
    bl_options = { 'REGISTER', 'UNDO' }

    rayon = FloatProperty( name="rayon",
            default=1., min=.1, max=100. )
           
    alpha = FloatProperty( name="alpha",
            default=.01, min=.01, max=5. )
           
    theta = FloatProperty( name="theta",
            default=10., min=10., max=100. )
           
    location = FloatVectorProperty( name="position" )
    rotation = FloatVectorProperty( name="rotation",
    description="rotation en radians" )


    def execute( self, context ):
        ob = ajouteVolume( context,
            self.rayon, self.alpha, self.theta )
        ob.location = self.location
        ob.rotation_euler = self.rotation
        #context.scene.objects.link(ob)
        #context.scene.objects.active = ob
        return { 'FINISHED' }




#    Le programme est accessible via le menu add




def menu_func( self, context ):
    self.layout.operator( "mesh.primitive_volume_add",
        text="Volume" )




def register():
   bpy.utils.register_module( __name__ )
   bpy.types.INFO_MT_mesh_add.prepend( menu_func )




def unregister():
    bpy.utils.unregister_module( __name__ )
    bpy.types.INFO_MT_mesh_add.remove( menu_func )




if __name__ == "__main__":
    register()


Remarque: plus les angles alpha et theta sont petits, plus la représentation du volume est précise.
En outre, [tex]\alpha[/tex] est un angle en radians tandis que [tex]\theta[/tex] est un angle en degrés !

Voilà ! En maîtrisant les bases de la programmation et grâce à des modules externes, on peut faire des choses vraiment intéressantes !

J'ai eu un avant-goût des matrices (pour effectuer les rotations de points sous forme de vecteurs) et je dois avouer que c'est extrêmement puissant comme type de fonction: plusieurs variables (ou antécédents) peuvent intervenir dans des calculs.

Salut

Dernière modification par lambda (12-08-2014 10:58:17)

Hors ligne

#9 03-08-2014 17:59:46

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Re : Cardioides et limaçons

Bonsoir,

J'ai restitué la surface de mon volume. Ce qui est particulier chez celui-ci c'est qu'en un point il y a intersection de sa surface.

J'ai réfléchi si, comme la plupart des surfaces, elle possède des faces orientées à l'extérieur et d'autres à l'intérieur. J'ai l'impression que ma surface est non-orientable, comme la surface de Klein...

Je n'ai aucune connaissance de la topologie et cette branche des Maths me semble hors de portée pour moi...

Voici des images pour vous donner une petite idée...

ext.png
int.png

Le code:

from math import cos, sin, tan, pi
import bpy
from bpy.props import *


"""
Programme qui trace sur le plan un nuage de
points appartenant à une courbe puis la fait
pivoter sur un axe afin d'engendrer un volume
"""


def matriceRotation(alpha):
    """
    Construction de la
    matrice de rotation
    sur l'axe y
   
    alpha: angle(en degré)
    """
   
    g = lambda angle: angle / 180. * pi
    #  on crée une fonction de conversion degrés => radians
   
    a = g(alpha)
    #  conversion de l'angle en radians
   
    return [[cos(a), 0, - sin(a)], [0, 1, 0], [sin(a), 0, cos(a)]]
    #  on renvoie la matrice de rotation sur l'axe y


def produitMatriceVec(A, V):
    """
    Produit matriciel
   
    V : vecteur
    A : matrice
    """
   
    dimV = len(V)
    #  dimension du vecteur d'entrée
   
    dimV2 = len(A)
    #  dimension du vecteur de sortie
   
    V2 = []
    #  vecteur de sortie
   
    for k in range(dimV2):
       
        acc = 0.
       
        for j in range(dimV):
           
            acc = A[k][j] * V[j] + acc
            #  produit matriciel
           
        V2.append(acc)
       
    return V2
    #  vecteur résultant du produit matrice-vecteur


def donneesCourbe(rayon, n):
    """
    Calcul des coordonnées
    des points de la moitié
    de la courbe en tenant
    compte de son axe de
    symétrie
    """
   
    pointsCourbe = []
    #  la liste des points de la courbe
   
    alpha = -pi/2
    #  angle en radians
   
    while alpha <= pi/2:
    #  calcul des coordonnées des points de la courbe
   
        x = (- cos(alpha) * (2 * sin(alpha) - 3 * cos(alpha) ** 2 - 1) * rayon / ( 3 * cos(alpha) ** 2 + 1 ))
        y = (x * (tan(alpha) / 2) + rayon)
        z = 0.
        #  fonction paramétrée, en coordonnées cartésiennes
       
        point = (x, y, z)
        #  on conserve temporairement les coordonnées du point
       
        pointsCourbe.append(point)
        #  on ajoute les coordonnées du point dans la liste
       
        alpha += n
        #  on augmente l'angle alpha de n radians
       
    return pointsCourbe
    #  on renvoie la liste des coordonnées des points de la courbe


def donneesVolume(pointsCourbe, n):
    """
    Calcul des coordonnées des
    points du volume par rotation
    de la courbe sur l'axe y
    """
   
    pointsVolume = []
    #  liste des points sur la surface du volume
   
    faces = []
   
    theta = 0
    #  angle en degré
       
    while theta <= 360.:
    #  tour de cercle
       
        for k in range(len(pointsCourbe)):
        #  Création du volume par rotation de la courbe sur l'axe y
   
            M = matriceRotation(theta)
            #  création de la nouvelle matrice de rotation d'angle theta
           
            pointsVolume.append(produitMatriceVec(M, pointsCourbe[k]))
            #  ajout des nouveaux points résultant de la rotation des points initiaux
           
        theta += n
        #  on augmente theta de n degrés
   
    for i in range(len(pointsVolume) - len(pointsCourbe)):
    #  on comble les faces
   
        A = i
        B = i + 1
        C = len(pointsCourbe) + B
        D = len(pointsCourbe) + A
       
        face = (A, B, C, D)
        faces.append(face)
        #  ajout des faces nouvellement crées dans la liste
   
   
    return pointsVolume, faces


def constructionVolume(context, nomObjet, points, faces):
    """
    Construction de la
    courbe dans l'espace
    """
   
    segments = []
    #  la liste des segments
       
    maillage = bpy.data.meshes.new(nomObjet)
    #  on crée le maillage
   
    objet = bpy.data.objects.new(nomObjet, maillage)
    #  on crée l'objet
   
    objet.location = (0, 0, 0)
    #  on donne la position de l'objet dans l'espace
   
    context.scene.objects.link(objet)
    context.scene.objects.active = objet
   
    maillage.from_pydata(points, segments, faces)
    maillage.update(calc_edges=True)
    #  à partir des données on affiche les points
   
    return objet


def ajouteVolume(context, rayon, alpha, theta):
   
    points, faces = donneesVolume(donneesCourbe(rayon, alpha), theta)
    return constructionVolume(context, "Volume", points, faces)


#  Interface utilisateur visuelle


class MESH_OT_primitive_volume_add(bpy.types.Operator):
   
    bl_idname = "mesh.primitive_volume_add"
    bl_label = "Volume"
    bl_options = {'REGISTER', 'UNDO'}
   
    rayon = FloatProperty(name="rayon",
            default=1., min=.1, max=100.)
           
    alpha = FloatProperty(name="alpha",
            default=.01, min=.001, max=5.)
           
    theta = FloatProperty(name="theta",
            default=10., min=1., max=100.)
           
    location = FloatVectorProperty(name="position")
    rotation = FloatVectorProperty(name="rotation",
    description="rotation en radians")
   
    def execute(self, context):
        ob = ajouteVolume(context,
            self.rayon, self.alpha, self.theta)
        ob.location = self.location
        ob.rotation_euler = self.rotation
        return {'FINISHED'}


#    Le programme est accessible via le menu: add


def menu_func(self, context):
    self.layout.operator("mesh.primitive_volume_add",
        text="Volume")


def register():
   bpy.utils.register_module(__name__)
   bpy.types.INFO_MT_mesh_add.prepend(menu_func)


def unregister():
    bpy.utils.unregister_module(__name__)
    bpy.types.INFO_MT_mesh_add.remove(menu_func)


if __name__ == "__main__":
    register()

Je vous remercie d'avance pour toute idée.
Au revoir.

Dernière modification par lambda (15-08-2014 09:10:04)

Hors ligne

#10 12-08-2014 17:02:24

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Re : Cardioides et limaçons

Bonjour,

Pas d'idées ? Confère le message ci-dessus.

Je met de côté ce problème qui est donc hors de mes compétences pour continuer d'autres petites découvertes.
J'ai essayé de regarder du côté des surfaces orientables mais ces textes (de surcroît en anglais), sont trop compliqués pour des néophytes comme moi.
Je ne me décourage pas pour autant et réserve ce problème pour plus tard quand j'aurais enfin les connaissances requises (... c'est-à-dire dans très, très longtemps ! )

Salut.

Dernière modification par lambda (12-08-2014 17:13:16)

Hors ligne

#11 12-08-2014 18:20:24

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : Cardioides et limaçons

Cher lambda,

tu as progressé à une vitesse telle que tu nous a dépassés...
Comment veux-tu qu'on te réponde ?
Nous, nous en sommes restés à la programmation "classique" : Blender, par ex, moi, connais pas ! Jamais approché !

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#12 12-08-2014 19:36:37

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Re : Cardioides et limaçons

Bonsoir,

Non non, yoshi, rassures-toi, je n'ai fait qu'utiliser une bibliothèque additionnelle, comme tu utiliserais une bibliothèque de plot 2D/3D.

La bibliothèque que propose Blender permet de projeter des points dans l'espace, modélisés par des matrices, dans le plan (grâce à openGL).
Ainsi, en fonction des matrices de projection usitées, nous pouvons afficher des objets selon différentes perspectives (isométrique, trois points de fuite, fish-eye, etc).
Le module permet en outre d'interagir avec l'interface du logiciel.

Je n'ai fait que créer des listes en Python, ce qui est à la portée de n'importe quelle personne qui connaît les bases du langage, en l’occurrence, Python.

Voici l'algorithme que j'ai créé :

Je calcule les coordonnées des points de la moitié de la courbe en tenant compte de son axe de symétrie, grâce à son équation paramétrée, sans oublier que l'on travaille dans l'espace et non dans le plan ;

J'engendre le volume par rotation de la courbe grâce à une matrice. Chaque point est donc modélisé par un tuple [tex](x, y, z)[/tex] qui nous indique sa position dans l'espace. Chaque nouveau point résulte du produit entre ma matrice de rotation sur un axe et ce vecteur sous forme de tuple. J'obtiens alors mon volume sous forme de nuage de points ;

Je restitue sa surface en créant des faces ;

Enfin, j'affiche à l'écran mon volume et grâce au module je peux tester certains paramètres de façon interactive.

J'aimerais que vous me disiez, au vu des images, si la surface est orientable ou non.

Je te remercie de m'avoir répondu. Ta réponse me fait très plaisir, me montre que tu portes de l'intérêt pour mes modestes travaux.

Salut.

Dernière modification par lambda (19-08-2014 11:51:43)

Hors ligne

#13 12-08-2014 20:15:17

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : Cardioides et limaçons

Bonsoir,

Tu fais de très belles choses...
As-tu déjà regardé ce qu'on disait des métiers de l'Infographie ? Vu que tu sembles être plutôt branché graphisme...
D'accord, ce n'est pas l'an prochain en 2nde que tu devras choisir ton orientation.
Cela dit, tu sembles avoir aussi de l'intérêt pour les matières scientifiques, donc pourquoi pas 1ere S et TS (en y choisissant l'enseignement de spécialité à ton goût) ?

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#14 12-08-2014 20:42:29

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Re : Cardioides et limaçons

Bonsoir,

Concernant mon orientation, je suis tantôt attiré par la Physique, parfois par la Chimie, et récemment les Mathématiques car c'est un domaine très fertile. En quatrième, j'étais passionné de Géologie ! Ceci dit, j'aime beaucoup la beauté qu'offrent ses figures géométriques , harmonieuses et étonnantes. Par ailleurs, il faut que je m'occupe de mon stage de Seconde, que je prépare mon Curriculum Vitæ, et fasse des demandes de stage dans des labos ...

Salut.

Dernière modification par lambda (13-08-2014 13:06:02)

Hors ligne

#15 12-08-2014 21:09:54

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : Cardioides et limaçons

Re,

Tiens? pour les esprits curieux, les téléchargements de BD gratuites, libres de droits, de JP Petit ici :
http://www.savoir-sans-frontieres.com/J … nloads.htm
Ne commets pas l'erreur de le sous-estimer.
Il est Docteur es Sciences.
Il a été professeur aux Beaux-Arts, responsable d'un service de Micro-informatique à la faculté de Lettres d'Aix-en-Provence, Astrophysicien, chargé de recherches au CNRS....
Il a enseigné pendant 5 ans les sciences à des non-scientifiques en utilisant la technique de la BD. Ses BD sont dans cet esprit : il a le don de rendre simple ce qui est très complexe...
Enfin, au moins sur le moment, parce que lorsqu'on tente de réexpliquer ça à quelqu'un, on s'aperçoit souvent qu'il faut retourner lire la BD...

Toutes ne sont du même niveau.
Tu jugeras par toi-même...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#16 12-08-2014 21:13:57

lambda
Membre
Inscription : 27-06-2014
Messages : 40

Re : Cardioides et limaçons

Bonsoir,

Merci beaucoup pour ton lien, je jette un coup d'oeil, et regarderai plus en profondeur demain, car il se fait tard
J'ai le [tex]Geometricon[/tex] du même auteur sur la géométrie non-euclidienne chez moi et je l'adore ,

Ciao

Dernière modification par lambda (13-08-2014 13:02:40)

Hors ligne

#17 12-08-2014 21:50:56

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 16 943

Re : Cardioides et limaçons

Ave,

Alors, tu vas te régaler...
(j'en ai une dizaine que j'avais achetés en librairie dans le temps).

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

Réponse rapide

Veuillez composer votre message et l'envoyer
Nom (obligatoire)

E-mail (obligatoire)

Message (obligatoire)

Programme anti-spam : Afin de lutter contre le spam, nous vous demandons de bien vouloir répondre à la question suivante. Après inscription sur le site, vous n'aurez plus à répondre à ces questions.

Quel est le résultat de l'opération suivante (donner le résultat en chiffres)?
quatre-vingt deux moins quatre-vingt un
Système anti-bot

Faites glisser le curseur de gauche à droite pour activer le bouton de confirmation.

Attention : Vous devez activer Javascript dans votre navigateur pour utiliser le système anti-bot.

Pied de page des forums