Forum de mathématiques - Bibm@th.net
Vous n'êtes pas identifié(e).
- Contributions : Récentes | Sans réponse
Pages : 1
#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
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
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
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 ...
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 radianswhile 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...
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 ydef 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-vecteurdef 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 courbedef 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 pointsVolumedef 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
#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 :
]
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
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 mathsimport bpy
# module du logicielfrom 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 ydef 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-vecteurdef 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 courbedef 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 pointsVolumedef 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 objetdef 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...
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 ydef 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-vecteurdef 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 courbedef 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, facesdef 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 objetdef 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
Pages : 1