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_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 generate_bgeom(step=None):
from openalea.lpy import Lsystem
import os
print('Scene generator launched')
l = Lsystem(
lsysfile, {
'RESOLUTION': 2,
'daystep': 1,
'TIMEBAR': False,
'LEAFY': True,
'WITH_INFLO': True,
'EXPORT_TO_MTG': False
})
if step is None:
firststep = 0
nbsteps = l.derivationLength
else:
firststep = step
nbsteps = step + 1
open(stepfile, 'w').write(str(nbsteps))
if not os.path.exists(workingrep): os.makedirs(workingrep)
for step in range(firststep, nbsteps):
if step == firststep: lstring = l.derive(firststep + 1)
else: lstring = l.derive(lstring, step, 1)
lscene = l.sceneInterpretation(lstring)
fname = join(workingrep, bgeomfile.format(str(step).zfill(4)))
lscene.save(tempbgeomfile)
os.rename(tempbgeomfile, fname)
print("Scene", step, "generated ...")
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 str2mtg(s):
#s = s.replace('N', 'F')
tree = AxialTree(s)
l = Lsystem()
l.addInterpretationRule('N --> F', 0)
geom_tree = l.homomorphism(tree)
scene = l.sceneInterpretation(geom_tree)
scale = dict(zip(('P','A','N', 'L', 'F'),(1,2,3,3,3)))
mtg = axialtree2mtg(tree, scale, scene)
return tree, mtg, scene
def str2mtg(s):
#s = s.replace('N', 'F')
tree = AxialTree(s)
l = Lsystem()
l.addInterpretationRule('N --> F', 0)
geom_tree = l.homomorphism(tree)
scene = l.sceneInterpretation(geom_tree)
scale = dict(list(zip(('P', 'A', 'N', 'L', 'F'), (1, 2, 3, 3, 3))))
mtg = axialtree2mtg(tree, scale, scene)
return tree, mtg, scene
class Vine(object):
def __init__(self, lpy_filename = vinedir + '/topvine.lpy'):
self.lpy_filename = lpy_filename
inter_row = 2.2# m
inter_plant = 1.1
self.domain_area = 3 * inter_plant * inter_row
def setup_canopy(self, age=0):
self.start = age
self.lsys = Lsystem(self.lpy_filename)
tree = run(self.lsys, nbstep = int(2 + age))
g = lpy2mtg(tree,self.lsys)
return g
def grow(self,g,time_control):
if len(time_control) > 0:
axiom = mtg2lpy(g,self.lsys)
#time_control.check('dt',1)
# /!\ TEMP /!\ ######################################
dt = 1
tree = run(self.lsys,axiom = axiom, nbstep = dt)
# /!\ TEMP /!\ ######################################
# tree = run(self.lsys,axiom = axiom, nbstep = time_control.dt)
return lpy2mtg(tree,self.lsys)
else :
return g
def reset(self):
if self.start is None:
self.start = 0
return setup_canopy(self.start)
def plot(self,g):
tree = mtg2lpy(g,self.lsys)
self.lsys.plot(tree)
return g
def generate_scene(self,g):
tree = mtg2lpy(g,self.lsys)
self.lsys.sceneInterpretation(tree)
return generateScene(tree)
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 generate_bgeom(step=None, endstep=None):
from openalea.lpy import Lsystem
import os
print('Scene generator launched')
l = Lsystem(
lsysfile, {
'SEED': 0,
'TREE': 0,
'RESOLUTION': 2,
'TIMESTEP': 1,
'TIMEBAR': False,
'LEAFY': True,
'WITH_INFLO': True,
'TEXTURE': True,
'GENERALIZEDCYLINDER': True,
'WITH_GLM': True,
'FRUIT_MODEL': False,
'GLM_RESTRICTION': None,
'_GLM_TYPE': 3,
'EXPORT_TO_MTG': False
})
if step is None:
firststep = 0
endstep = l.derivationLength
else:
firststep = step
if endstep is None:
endstep = l.derivationLength
else:
assert endstep < l.derivationLength
open(stepfile, 'w').write(str(endstep))
if not os.path.exists(workingrep): os.makedirs(workingrep)
for step in range(firststep, endstep):
if step == firststep: lstring = l.derive(firststep + 1)
else: lstring = l.derive(lstring, step, 1)
lscene = l.sceneInterpretation(lstring)
fname = join(workingrep, bgeomfile.format(str(step).zfill(4)))
lscene.save(tempbgeomfile)
os.rename(tempbgeomfile, fname)
print("Scene", step, "generated ...")
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 lpy_plot(self, line):
from math import ceil, sqrt, floor
try:
ip = get_ipython()
except NameError:
ip = None
args = parse_argstring(self.lpy_plot, line)
file = args.file
sizes = [int(i.strip()) for i in args.size.split(',')]
cell = args.cell
size_display = (int(sizes[0]),
int(sizes[1])) if len(sizes) > 1 else (int(sizes[0]),
int(sizes[0]))
ls = Lsystem(file)
rows = cols = ceil(sqrt(ls.derivationLength + 1))
size = rows * cell
start = -size / 2 + cell / 2
sw = SceneWidget(size_display=size_display, size_world=size)
sw.add(ls.sceneInterpretation(ls.axiom), position=(start, start, 0))
def plot():
tree = ls.axiom
for i in range(1, ls.derivationLength):
row = floor(i / rows)
col = (i - row * cols)
x = row * cell + start
y = col * cell + start
tree = ls.derive(tree, i, 1)
sw.add(ls.sceneInterpretation(tree), (x, y, 0))
ip.events.unregister('post_run_cell', plot)
if ip:
ip.events.register('post_run_cell', plot)
return sw
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: {} 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:
ind_part += "3 %i %i %i\n" % \
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)
def shoot_init(carbon_seed_stock=0.1):
lsys = Lsystem(str(os.path.join(lsysdir, 'morphogenesis.lpy')), {'carbon_seed_stock': carbon_seed_stock})
axialtree = lsys.axiom
scene = lsys.sceneInterpretation(axialtree)
return lpy2mtg(axialtree, lsys, scene)
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)
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
