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