Bonsoir,
 
Je dois actuellement programmer un Lsystem en python pour Maya.
Seulement j'ai un probleme au niveau de la gestion des deplacement en 3D.
Au niveau de la 2D ca gere mais une fois que je rajoute l'axe Z, je me perd totalement dans les calculs de vecteurs.
Voici mon code:
 
# L-System Generator
 
import maya.cmds as cmds
import math as math
 
class LSystem:
 ensembleRegle = {}
 
 def __init__(self):
   self.ensembleRegle = {}
 
 def setBase( self, aBase ):
  self.systemBase = aBase
 
 def ajouterRegle( self, variableARemplacer, nouvelleChaine):
  # Add the rule to tule array
  self.ensembleRegle[ variableARemplacer ] = nouvelleChaine
 
 def iteration( self, aBase, nombreIteration ):
 
  if nombreIteration > 0:
   replaced = ""
   for i in aBase:
    replaced = replaced + self.ensembleRegle.get(i,i)
   aBase = replaced
   return self.iteration( aBase, nombreIteration-1 )
  else:
   return aBase
 
class Point3D():
    def __init__(self, coordonneeX, coordonneeY, coordonneeZ):
 self.x = coordonneeX
 self.y = coordonneeY
 self.z = coordonneeZ
 
def drawLine( aStartPoint, aEndPoint,compteur ):
    compteur=compteur+1
    test1=cmds.circle(nr=(0,1,0),c=(aStartPoint.x, aStartPoint.y, aStartPoint.z), r=0.2)
    compteur=compteur+1
    test2=cmds.circle(nr=(0,1,0),c=(aEndPoint.x, aEndPoint.y, aEndPoint.z), r=0.2)
    cmds.select(test1,test2)
    cmds.loft()
    return
 
def calculateVectorAroundZ( aLength, aRotation ):
 radians = math.pi * aRotation / 180
 return Point3D( math.sin(radians), math.cos(radians), 0 )  
 
def calculateVectorAroundX( aLength, aRotation ):
 radians = math.pi * aRotation / 180
 return Point3D( 0, math.cos(radians),-(math.sin(radians)))  
 
def calculateVectorAroundY( aLength, aRotation ):
 radians = math.pi * aRotation / 180
 return Point3D( math.cos(radians), 0 ,math.sin(radians))  
 
def visualizeLSystem( aString ):
 chaine = aString
 i = 0  # Where at the input string we start from
 angle = 0  # Degrees, nor radians
 turn = 20  # How much we turn
 length = 1.0  # Unit length of an advancement
 pointActuel = Point3D( 0.0, 0.0, 0.0 ) # Start from origo
 compteur=0
 PileCoordonnee = [] # Stack where to store coordinates
 PileAngle = []  # Stack to store angles
 rotationX=0
 rotationY=0
 rotationZ=0
 
 while ( i < len( chaine ) ):
  if chaine[i] == 'F':
   if rotationZ == 1 :
    vector = calculateVectorAroundZ( length, angle )
    rotationZ = 0
    nouveauPoint = Point3D( pointActuel.x + vector.x, pointActuel.y + vector.y, pointActuel.z + vector.z )
    drawLine( pointActuel, nouveauPoint,compteur)
    pointActuel = nouveauPoint
   elif rotationX == 1 :
    vector = calculateVectorAroundX( length, angle )
    rotationX = 0
    nouveauPoint = Point3D( pointActuel.x + vector.x, pointActuel.y + vector.y, pointActuel.z + vector.z )
    drawLine( pointActuel, nouveauPoint,compteur)
    pointActuel = nouveauPoint
   elif rotationY == 1 :
    vector = calculateVectorAroundZ( length, angle )
    rotationY = 0
    nouveauPoint = Point3D( pointActuel.x + vector.x, pointActuel.y + vector.y, pointActuel.z + vector.z )
    drawLine( pointActuel, nouveauPoint,compteur)
    pointActuel = nouveauPoint
  elif chaine[i] == 'f':
   vector = calculateVector( length, angle )
   nouveauPoint = Point3D( pointActuel.x + vector.x, pointActuel.y + vector.y, pointActuel.z + vector.z )
   pointActuel = nouveauPoint
  elif chaine[i] == '-':
   angle = angle - turn
   rotationZ=1
  elif chaine[i] == '+':
   angle = angle + turn
   rotationZ=1
  elif chaine[i] == '[':
   PileCoordonnee.append( pointActuel )
   PileAngle.append( angle )
  elif chaine[i] == ']':
   pointActuel = PileCoordonnee.pop()
   angle = PileAngle.pop()
  elif chaine[i] == '&':
   angle = angle - turn
   rotationX=1
  elif chaine[i] == '^':
   angle = angle + turn
   rotationX=1
  elif chaine[i] == '/':
   angle = angle - turn
   rotationY=1
  elif chaine[i] == '~':
   angle = angle + turn
   rotationY=1
  else:
   print chaine[i] + ": ignored"
 
  # Move to the next drawing directive
  i = i + 1
 
 return
 
### Example Usage ###
 
system = LSystem()
 
system.ajouterRegle( "F", "F[+F][/F]&F[-F][^F]" )
nombreIteration = 3
axiom = "F"
 
visualizeLSystem( system.iteration( axiom, nombreIteration ) )
 
### Exemple petit arbre ###
#turn = 25
#system.ajouterRegle( "X", "F-[[X]+X]+F[+FX]-X" )
#system.ajouterRegle( "F", "F+F-F-F+F" )
#axiom = "X"
 
### Exemple grand arbre ###
#system.ajouterRegle( "F", "F[+F]F[-F][F]" )
#nombreIteration = 5
#axiom = "F"
 
 
Quelqu'un aurait une idée pour m'aider. Je n'ai rien trouvé sur internet qui n'utilise pas la librairie Turtle, que je ne dois pas utiliser.
Merci d'avance