def run_lsys(**kwds):
params = {k: v for k, v in _lsys_params.iteritems()}
params.update(kwds)
l = Lsystem('sensitivityanalysis.lpy', params)
lstring = l.iterate()
lscene = l.sceneInterpretation(lstring)
return lstring, lscene
def test_mtglpy_topvine():
fn = path('vinemtg_n.lpy')
if not fn.exists():
return
l = Lsystem(str(fn))
parameters = {}
parameters['carto_file'] = 'geom_n.dat'
parameters['picle_file'] = 'vine_n.dat'
parameters['TTfin'] = None
#l.context().updateNamespace(parameters)
c_iter = l.getLastIterationNb()
nbstep = l.derivationLength - c_iter
tree = l.iterate(l.axiom,c_iter,nbstep)
scene = l.sceneInterpretation(tree)
mtg = lpy2mtg(tree, l, scene)
print len(mtg)
axial_tree = AxialTree()
axial_tree = mtg2lpy(mtg, l, axial_tree)
g = lpy2mtg(axial_tree, l, scene)
assert len(g) == len(mtg)
#axial_tree = mtg2axialtree(mtg, scale, parameters, axial_tree)
# Check
assert True
return mtg, tree, axial_tree
def test_mtglpy_topvine():
fn = path('vinemtg_n.lpy')
if not fn.exists():
return
l = Lsystem(str(fn))
parameters = {}
parameters['carto_file'] = 'geom_n.dat'
parameters['picle_file'] = 'vine_n.dat'
parameters['TTfin'] = None
#l.context().updateNamespace(parameters)
c_iter = l.getLastIterationNb()
nbstep = l.derivationLength - c_iter
tree = l.iterate(l.axiom, c_iter, nbstep)
scene = l.sceneInterpretation(tree)
mtg = lpy2mtg(tree, l, scene)
print(len(mtg))
axial_tree = AxialTree()
axial_tree = mtg2lpy(mtg, l, axial_tree)
g = lpy2mtg(axial_tree, l, scene)
assert len(g) == len(mtg)
#axial_tree = mtg2axialtree(mtg, scale, parameters, axial_tree)
# Check
assert True
return mtg, tree, axial_tree
def run_lsystem(lsystem='simple_maize_nolight.lpy', parameters=None):
if parameters:
lsys = Lsystem(lsystem, {'parameters': parameters})
else:
lsys = Lsystem(lsystem)
lstring = lsys.iterate()
lscene = lsys.sceneInterpretation(lstring)
return lsys, lstring, lscene
def force_cut(lstring):
fake_rule = """
Fake:
produce Fake"""
fake_lsys = Lsystem()
fake_lsys.addRule(fake_rule)
fake_lsys.axiom = lstring
return fake_lsys.iterate()
def test_cut_bug():
lsystem_file = pj(data_access.get_data_dir(), 'check_cut_module.lpy')
lsys = Lsystem(lsystem_file)
lstring = lsys.iterate()
# cut branches
new_lstring = force_cut(lstring)
lscene = lsys.sceneInterpretation(lstring)
for sid in lscene.todict():
assert sid in range(len(lstring))
# suucceed if correction is needed (old lpy version)
# assert new_lstring[sid].name == 'Internode'
# succeed on more recent lpy version
assert lstring[sid].name == 'Internode'
def run(self, sim_id=None, dry_run=False, **kwds):
"""Run WALTer in project dir
Parameters
----------
sim_id:
simulation identifier
dry_run: (bool)
prevent running the simulation (do only side effects).
**kwds:
walter parameters values (as named arguments)
Examples
--------
p = Project()
p.run(nb_plt_utiles=1,
dist_border_x=0,
dist_border_y=0,
nbj=30,
beginning_CARIBU=290)
Returns
-------
the lsystem and lstring generated by the run
"""
self.activate()
already_known_id = self.itable.keys()
if sim_id is None:
sim_id = self.get_id(kwds)
if sim_id not in already_known_id:
self.update_itable()
lsys, lstring = None, None
if not dry_run:
lsys = Lsystem(self.walter, {'params': kwds, 'ID': sim_id})
time_start = time.time()
lstring = lsys.iterate()
time_stop = time.time()
with open(
self.output_path(sim_id=sim_id) / "Simulation_time.txt",
'w') as time_file:
time_file.write(str(time_stop - time_start))
return lsys, lstring
def test_mtglpy():
fn = path('ex_luz4.lpy')
if not fn.exists():
return
l = Lsystem('ex_luz4.lpy')
tree = l.iterate()
scene = l.sceneInterpretation(tree)
mtg = lpy2mtg(tree, l, scene)
print(len(mtg))
axial_tree = AxialTree()
axial_tree = mtg2lpy(mtg, l, axial_tree)
print(len(axial_tree))
#axial_tree = mtg2axialtree(mtg, scale, parameters, axial_tree)
# Check
assert True
return mtg, tree
def test_mtglpy():
fn = path('ex_luz4.lpy')
if not fn.exists():
return
l = Lsystem('ex_luz4.lpy')
tree = l.iterate()
scene = l.sceneInterpretation(tree)
mtg = lpy2mtg(tree, l, scene)
print len(mtg)
axial_tree = AxialTree()
axial_tree = mtg2lpy(mtg, l, axial_tree)
print len(axial_tree)
#axial_tree = mtg2axialtree(mtg, scale, parameters, axial_tree)
# Check
assert True
return mtg, tree
def generate_mtg(trees=list(range(3)), params=dict()):
from openalea.lpy import Lsystem
from openalea.mtg import MTG
from openalea.mtg.algo import union
g = None
for tree in trees:
print('Generate tree', tree)
nparams = params.copy()
nparams.update({
'TREE': tree,
'TIMESTEP': 180 if not params['FRUIT_MODEL'] else 90,
'EXPORT_TO_MTG': True,
'PARALLELFRUITMODEL': False
})
nparams.setdefault('WITH_GLM', True)
l = Lsystem(basename(lsysfile), nparams)
lstring = l.iterate()
resmtg = l.resultmtg
assert type(resmtg) == MTG
if g is None:
g = resmtg
else:
g = union(g, resmtg)
return g
class LPyModel(PythonModel):
dtype = 'LSystem'
mimetype = 'text/vnd-lpy'
def __init__(self, *args, **kwargs):
PythonModel.__init__(self, *args, **kwargs)
if self.name is None:
self.name = 'LPyModel'
self._step = 1
self.lsystem = Lsystem()
self.axialtree = AxialTree()
self.scene_name = self.name + '_scene'
def __copy__(self):
m = PythonModel.__copy__(self)
m.set_code(self._initial_code)
m.lsystem = self.lsystem
m.axialtree = self.axialtree
m.scene_name = self.scene_name
return m
def init(self, *args, **kwds):
self._step = 1
self._push_ns()
self._fill_namespace(*args, **kwds)
# BEGIN ACTUAL CODE RUN
self.lsystem.setCode(str(self.code), self._ns)
if "axiom" in self._ns and self._ns['axiom']:
self.lsystem.axiom = self._ns['axiom']
elif "lstring" in self._ns and self._ns['lstring']:
self.lsystem.axiom = self._ns['lstring']
self.axialtree = self.lsystem.axiom
# END ACTUAL CODE RUN
self._populate_ns()
self._pop_ns()
return self.output_from_ns(self._ns)
def output_from_ns(self, namespace):
# get outputs from namespace
outputs = []
if self.outputs_info:
if len(self.outputs_info) > 0:
for outp in self.outputs_info:
if outp.name.lower() in ["axialtree", "lstring"]:
outputs.append(self.axialtree)
elif outp.name.lower() == "lsystem":
outputs.append(self.lsystem)
elif outp.name.lower() == "scene":
outputs.append(self.lsystem.sceneInterpretation(self.axialtree))
elif outp.name in namespace:
outputs.append(namespace[outp.name])
else:
continue
# Add output to namespace
# if output is not in namespace, this line is not run (see "continue" above)
self._ns[outp.name] = outputs[-1]
if len(outputs) == 0:
return None
elif len(outputs) == 1:
return outputs[0]
else:
return outputs
def run(self, *args, **kwds):
nstep = kwds.pop('nstep', None)
self.init(*args, **kwds)
if nstep is None:
self.axialtree = self.lsystem.iterate()
else:
self.axialtree = self.lsystem.iterate(nstep)
self.lsystem.context().getNamespace(self._ns)
self.outputs = self.output_from_ns(self._ns)
return self.outputs
def step(self, *args, **kwds):
nstep = kwds.pop('nstep', None)
if self._step > self.lsystem.derivationLength:
self._step = 0
if nstep is None:
self.axialtree = self.lsystem.iterate(self._step)
else:
self.axialtree = self.lsystem.iterate(nstep)
self.outputs = self.output_from_ns(self._ns)
self._step += 1
return self.outputs
def animate(self, *args, **kwds):
self.init()
self.axialtree = self.lsystem.animate()
self.outputs = self.output_from_ns(self._ns)
self._step = self.lsystem.derivationLength + 1
return self.outputs
def set_code(self, code):
"""
Set the content and parse it to get docstring, inputs and outputs info, some methods
"""
self._initial_code, control = import_lpy_file(code)
self._doc = get_docstring(code)
docstring = parse_lpy(code)
if docstring is not None:
model, self.inputs_info, self.outputs_info = parse_doc(docstring)
# Default input
if self.inputs_info == []:
self.inputs_info = [InputObj('lstring:IStr')]
# Default output
if self.outputs_info == []:
self.outputs_info = [OutputObj("lstring:IStr")]
def _set_code(self, code):
self.set_code(code)
def _set_axialtree(self, axialtree):
self._axialtree = adapt_axialtree(axialtree, self.lsystem)
code = property(fget=lambda self: self._initial_code, fset=_set_code)
axialtree = property(fget=lambda self: self._axialtree, fset=_set_axialtree)
usage = """Convert lpy file to ply format
usage: {} FILE"""
if len(sys.argv) != 2:
print(usage.format(__name__))
lpy_file = sys.argv[1]
lsys = Lsystem(lpy_file)
ply_file = os.path.splitext(
os.path.basename(os.path.expanduser(lpy_file)))[0]
ply_file = ply_file + '.ply'
n = lsys.derivationLength
tree = lsys.axiom
for i in range(n):
# Apply rewritting rules on the tree -> One step of simulation
tree = lsys.iterate(tree, 1)
scene = lsys.sceneInterpretation(tree)
d = Tesselator()
nind = 0
nvert = 0
vert_part = ''
ind_part = ''
for shapes in scene.todict().values():
for shape in shapes:
d.process(shape)
c = shape.appearance.ambient
for p in d.result.pointList:
vert_part += "%f %f %f %i %i %i\n" % \
(p.x, p.y, p.z, c.red, c.green, c.blue)
for i3 in d.result.indexList:
def shoot_grow(g, demand_only=True):
lsys = Lsystem(str(os.path.join(lsysdir, 'morphogenesis.lpy')), {'demand_only': demand_only})
lsys.axiom = mtg2lpy(g, lsys, AxialTree())
axt = lsys.iterate()
scene = lsys.sceneInterpretation(axt)
return lpy2mtg(axt, lsys, scene)
F(x) :
produce F(x/3.0)+F(x/3.0)--F(x/3.0)+F(x/3.0)
endlsystem
'''
lsystem.setCode(str(code), context)
lsystem.axiom = "_(0.01)-(90)F(1)"
print('\n----lsystem:')
print(lsystem)
print('\n----axialtree:', axialtree)
axialtree = lsystem.iterate(3)
print('\n----lsystem:')
print(lsystem)
print('\n----axialtree:', axialtree)
lsystem.getLastIterationNb() # iterate 4 -> getLastIterationNb == 3
lsystem.derivationLength # see keyword in lpy code
scene = lsystem.sceneInterpretation(axialtree)
print(scene)
world.add(scene, name='test')
# axialtree = adapt_axialtree(axialtree, lsystem)
def runmodel(fname):
from openalea.lpy import Lsystem
l = Lsystem(fname)
lstring = l.iterate()
l.plot(lstring)
F(x) :
produce F(x/3.0)+F(x/3.0)--F(x/3.0)+F(x/3.0)
endlsystem
'''
lsystem.setCode(str(code), context)
lsystem.axiom = "_(0.01)-(90)F(1)"
print('\n----lsystem:')
print(lsystem)
print('\n----axialtree:', axialtree)
axialtree = lsystem.iterate(3)
print('\n----lsystem:')
print(lsystem)
print('\n----axialtree:', axialtree)
lsystem.getLastIterationNb() # iterate 4 -> getLastIterationNb == 3
lsystem.derivationLength # see keyword in lpy code
scene = lsystem.sceneInterpretation(axialtree)
print(scene)
world.add(scene, name='test')
# axialtree = adapt_axialtree(axialtree, lsystem)
def createtree(path):
lsys = Lsystem(path)
lstring = lsys.iterate()
lscene = lsys.sceneInterpretation(lstring)
return lscene
