L-Py in scripts or in third party applications¶
Manipulation of Lsystems¶
Using the openlea.lpy module, Lsystems can be manipulated directly using the ‘Lsystem’ object. Main actions are the creation and the derivation of an Lsystem.
Creation¶
To create an Lsystem, a file or a string containing the code can be used.
from openalea.lpy import *
l = Lsystem("myfile.lpy")
or
l = Lsystem()
l.setCode(mycode)
To configure the creation of an Lsystems by setting predefined variables, it is possible to pass as an argument a dictionnary of variables.
variables = {'VAR1' : VALUE1 , ... }
l = Lsystem("myfile.lpy", variables)
In such case, the variables contained in the dictionnary may overwrite graphically defined variables if they have similar names or variable in the model defined using the extern
command.
The extern
command can be used to set variables that are defined with default value in the Lsystem but can be redefined externally. For instance, in the following example, the ``VAR1``is redefined externally.
# myfile.lpy
extern(VAR1 = VALUE1)
Axiom: F(VAR1)
# application of the lsystem
l = Lsystem("myfile.lpy", {'VAR1' : VALUE2})
Derivation¶
The standard way to apply derivation on an Lstring using a Lsystem is to use the function derive
. Its parameters are the lstring on which derivation is applied, the iteration number to which the derivation corresponds and the number of iterations to apply. Default values for lstring, iteration number and number of iterations are the axiom, 0 and derivation length respectivelly. An extra optimization parameter makes it possible to indicates if the lstring has already been used for interpretation (and thus environmental modules are completed).
Thus an Lsystem can be simulated with the following code
l = Lsystem("myfile.lpy")
lstring = l.derive()
To have all intermediate lstrings, the following code can be used
l = Lsystem("myfile.lpy")
lstring = l.axiom
for i in xrange(l.derivationLength):
lstring = l.derive(lstring, i, 1)
A more compact version using iterator is
lsystem = Lsystem("myfile.lpy")
for lstring in lsystem:
pass
Note that the function interpret
of the Lsystem makes it possible to apply interpretation rules on an Lstring and return the resulting interpretation string.
lsystem = Lsystem("myfile.lpy")
for lstring in lsystem:
ilstring = lsystem.interpret(lstring)
Graphical output¶
A visual interpretation can be made using a 3D turtle. For this the function turtle_interpretation
of the Lsystem can be used. Custom turtle deriving from PlantGL Turtle
class can be defined and used. By default, a PglTurtle
is used which output PlantGL primitives.
A computation of the PlantGL representation at each step can thus be defined in the following way:
from openalea.lpy import *
from openalea.plantgl.all import *
lsystem = Lsystem("myfile.lpy")
for lstring in lsystem:
t = PglTurtle()
lsystem.turtle_interpretation(lstring, t)
scene = t.getScene()
Note that an interpretation of the lstring as a PlantGL scene can be computed directly with the sceneInterpretation
of the Lsystem object.
from openalea.lpy import *
lsystem = Lsystem("myfile.lpy")
for lstring in lsystem:
scene = lsystem.sceneInterpretation(lstring)
Plotting directly the 3D scene from the Lstring is also possible with the function plot
of the Lsystem object.
from openalea.lpy import *
lsystem = Lsystem("myfile.lpy")
for lstring in lsystem:
lsystem.plot(lstring)
In such case, the viewer used to plot the 3D scene can be parameterized (By default it is the PlantGLViewer). For this the function registerPlotter
of the lpy module can be used. It allows to register a plotter whose following interface are expected
class Plotter:
def __init__(self):
pass
def plot(self,scene):
pass
def save(self, fname, format):
""" Save the view of the 3D scene in fname with the given format (PNG, JPG) """
pass
def selection(self):
"""Should return a list of id of selected elements """
pass
def waitSelection(self, txt):
""" Wait for selection of elements with the following text """
pass
From the Lsystem point of view, it is possible to use the function animate
or record
to plot at each step the 3D interpretation of the Lsystem using the defined plotter.
Graphical Parameters Manipulation¶
The L-Py GUI makes it possible to define graphical parameters by the user and usable within the simulation. For this, some code are defined at the end of the Lsystem code. In addition to the variables defined in its namespace, it is possible to have access to the predefined graphical parameters of an Lsystems using some globals variables:
lsystem = Lsystem("myfile.lpy")
# A list of scalar object that defined type, value and bounds
# of every graphical scalar parameters
print lsystem.__scalars__
# A list of information on graphical objects.
# It is a list of panel.
# A panel is a tuple with panelinfo and list of objets.
# Objects are defined as a tuple with a type and the object.
# Panelinfo is a dictionnary of properties.
print lsystem.__parameterset__
To write parameters at the end of an Lsystem code, it is possible to use function defined in openalea.lpy.simu_environ
from openalea.lpy.simu_environ import initialisationFunction
from openalea.lpy.gui.scalar import IntegerScalar
lc = LsysContext()
# Setting the options of Lsystem execution
lc.options.setSelection('Module declaration',1)
# Defining graphical scalar parameter
scalars = [IntegerScalar('default_scalar', 1, 0, 100)]
initcode = initialisationFunction(lc, scalars = scalars,
visualparameters = None,
colorlist = None,
referencedir = savedir)