Forum de mathématiques - Bibm@th.net

Quand on écrit [tex]0, \bar{9}...[/tex] , on sait que cela représente un réel. L'écriture décimale d'un réel peut comporter une infinité de chiffres après la virgule, mais la partie entière d'un réel a forcément une écriture décimale finie

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.

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()

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

from turtle import goto
from math import cos, sin, pi

def convertionDegreRadian(angle):
    return angle*pi/180

def courbe(taille, angle):
    for angleAlpha in range(angle):
        x = cos(convertionDegreRadian(angleAlpha))*taille
        y = (sin(convertionDegreRadian(angleAlpha))*taille)/2
        goto(x, y)

courbe(100, 180)