예제 #1
0
    def load(index=0, dir='./adel_saved', basename=None, load_geom=True):
        if basename is None:
            if not os.path.exists(dir):
                os.mkdir(dir)
            basename_geom = dir + '/scene%04d' % (index)
            basename_adel = dir + '/adel%04d' % (index)
        else:
            basename_adel = basename_geom = basename
        fgeom = basename_geom + '.bgeom'
        fg = basename_adel + '.pckl'
        if not os.path.exists(fgeom) or not os.path.exists(fg):
            raise IOError('adel cannot find saved files')

        f = open(fg)
        g = pickle.load(f)
        f.close()

        # backward compatibility
        if isinstance(g, list):
            g, age = g
            root = g.node(0)
            meta = {'canopy_age': age}
            if 'meta' not in g.property_names():
                root.meta = meta
            else:
                root.meta.update(meta)

        if load_geom:
            s = Scene()
            s.read(fgeom, 'BGEOM')
            geom = {sh.id: sh.geometry for sh in s}
            g.add_property('geometry')
            g.property('geometry').update(geom)

        return g
예제 #2
0
        def display(self, color=(190, 205, 205), add=False):
            """
		Display the 2-cells of a 2-G-Map using the ordered orbit of its darts in PlantGL.
		For each face element, retrieve the position of its ordered face darts and add a FaceSet PlantGL object to the scene.
		Example : s += pgl.Shape(pgl.FaceSet( [[0,0,0],[1,0,0],[1,1,0],[0,1,0]], [[0,1,2,3]]) , pgl.Material((0,100,0))) # for a green square
		"""
            from openalea.plantgl.all import Scene, Shape, Material, FaceSet, Viewer
            from random import randint
            s = Scene()
            for facedart in self.elements(2):
                lastfart = facedart
                positions = []
                for dart in self.oderedorbit(facedart, [0, 1]):
                    if self.alpha(0, dart) != lastfart:
                        positions.append(self.get_position(dart))
                    lastfart = dart
                if color is None:
                    mat = Material(
                        (randint(0, 255), randint(0, 255), randint(0, 255)))
                else:
                    mat = Material(tuple(color), diffuse=0.25)
                s.add(
                    Shape(FaceSet(positions, [range(len(positions))]), mat,
                          facedart))
            if add:
                Viewer.add(s)
            else:
                Viewer.display(s)
예제 #3
0
    def scene(self, view="axis", scene=None):
        """
        Compute a scene from a tree squeleton.

        view='axis', 'node', 'polyline' or 'point'
        view specify if we compute a shape by axis, a shape by node
        or just a polyline.
        """
        if not scene:
            scene = Scene()

        server = self.server

        max_order = server.max_order

        for order in range(max_order):
            self.axes(order, view)

        if server.has_leaf():
            if view not in ['point']:
                self.leaves()
        else:
            self.axes(max_order, view)

        map(lambda x: scene.add(x), self._shapes)
        return scene
예제 #4
0
파일: gmap.py 프로젝트: flyingrub/gmap
 def display(self, color=[190, 205, 205], add=False, transparency=0):
     from openalea.plantgl.all import Scene, Shape, Material, FaceSet, Viewer
     from random import randint
     s = Scene()
     for facedart in self.elements(2):
         lastdart = facedart
         positions = []
         for dart in self.orderedorbit(facedart, [0, 1]):
             if self.alpha(0, dart) != lastdart:
                 positions.append(self.get_position(dart))
             lastdart = dart
         if color is None:
             mat = Material(
                 (randint(0, 255), randint(0, 255), randint(0, 255)),
                 transparency=transparency)
         else:
             mat = Material(tuple(color),
                            diffuse=0.25,
                            transparency=transparency)
         s.add(
             Shape(FaceSet(positions, [range(len(positions))]), mat,
                   facedart))
     if add:
         Viewer.add(s)
     else:
         Viewer.display(s)
예제 #5
0
  def darts2pglscene(self, textsize = None):
            from openalea.plantgl.all import Scene, Shape, Material, FaceSet, Polyline, PointSet, Translated, Text, Font
            from numpy import array
            s = Scene()
            th = 0.1
            matdart = Material((0,0,0))
            matalphai = [Material((100,100,100)),Material((0,200,0)),Material((0,0,200)),Material((200,0,0))]
            matlabel =  Material((0,0,0))
            alphaipos = [{} for i in xrange(3)]
            vertex = []
            font = Font(size=textsize if textsize else 10)
 
            def process_edge(dart, facecenter = None, fshift = [0.,0.,0.]):
                try:
                    edgecenter = self.cell_center(dart,1)
                except:
                    print 'Cannot display dart', dart,': no coordinates.'
                    return
                eshift = array(fshift)
                if not facecenter is None : 
                    eshift += (facecenter-edgecenter)*2*th 
 
                for cdart in [dart, self.alpha(0,dart)]:
                    pi = self.get_position(cdart) 
                    pdir = (edgecenter-pi)
                    pi =  pi + (pdir*(th*3) + eshift)
                    vertex.append(pi)
                    dartlengthratio = 0.6
                    s.add(Shape(Polyline([pi,pi+pdir*dartlengthratio]) , matdart, id = cdart))
                    s.add(Shape(Translated(pi+pdir*0.5, Text(str(cdart),fontstyle=font)), matlabel, id=cdart))
                    for i in xrange(0,3):
                        oppidart = self.alpha( i,cdart)
                        if oppidart != cdart:
                            if i == 0 : 
                                alphaidartpos = pi+pdir* dartlengthratio
                            else:
                                alphaidartpos = pi+pdir*(0.1*i)
                            if alphaipos[i].has_key(oppidart):
                                s.add(Shape(Polyline([alphaipos[i][oppidart],alphaidartpos],width=5) , matalphai[i]))
                            else:
                                alphaipos[i][cdart] = alphaidartpos
 
            def process_face(dart, cellcenter = None, cshift = [0.,0.,0.]):
                try:
                    facecenter = self.cell_center(fid,2)
                except:
                    facecenter = None
                
                fshift = cshift 
                if not cellcenter is None and not facecenter is None: fshift = (cellcenter-facecenter)*th
                for dart in self.incident_cells(fid,2,1):
                    process_edge(dart, facecenter, fshift)         
                       
            for fid in self.elements(2):
                    process_face(fid)
 
            s.add(Shape(PointSet(vertex, width=5) ,Material((0,0,0)) ))
            return s
예제 #6
0
def convex():
    s = Scene()
    s.read('pruning.geom')
    assert len(s) == 740

    leaves = get_leaves_from_scene(s)
    assert len(leaves) == 177

    return leaves
예제 #7
0
 def save(self, obj, filename):
     """
     Store obj into filename
     """
     filename = Path(filename)
     try:
         from openalea.plantgl.all import Scene
         sc = Scene()
         sc.add(obj)
         return sc.save(str(filename), "BGEOM")
     except ImportError:
         warnings.warn("You must install PlantGL if you want to load a BGEOM object.")
     except Exception, e:
         print e
         warnings.warn("Impossible to save the scene for object %s into %s" % (obj, filename))
예제 #8
0
def get_leaves_from_scene(scene):
    """parse a scene and extract the leaves.

    :param Scene scene: a PGL scene
    :return: a new scene with leaves shapes only

    This is appropriate for the scene given by stocatree simulations only.
    where leaves are bezierPatch types.

    .. todo:: improve the code to be more robust and generic.

    """
    shapes = []
    from openalea.plantgl.all import BezierPatch, Scene
    for sh in scene:
        try:
            if type(sh.geometry.geometry.geometry.geometry.geometry
                    ) == BezierPatch:
                shapes.append(sh)
        except:
            pass

    scene = Scene()
    for x in shapes:
        scene += x
    return scene
예제 #9
0
def generate_pov(i=0, nbpovprocess=1, maxstep=None):
    """ generate ith images modulo nbpovprocess """
    print('Image generator ', i, ' launched')
    from openalea.plantgl.all import Scene, Tesselator, PovFilePrinter
    print('Look at', stepfile)
    wait_for_file(stepfile)
    if maxstep is None:
        maxstep = int(open(stepfile, 'r').read())
    step = i
    os.chdir(workingrep)
    while step < maxstep:
        bgeomfname = bgeomfile.format(str(step).zfill(4))
        steppovfile = povfile.format(str(step).zfill(4))
        stepimgfile = imgfile.format(str(step).zfill(4))
        if os.path.exists(stepimgfile):
            print('Image ', step, 'already computed ...')
            step += nbpovprocess
            continue
        wait_for_file(bgeomfname)
        lscene = Scene(bgeomfname)
        for sh in lscene:
            sh.setComputedName()
        lscene.save(steppovfile)
        #tess = Tesselator()
        #printer = PovFilePrinter(steppovfile,tess)
        #lscene.apply(printer)
        if os.path.exists(steppovfile):
            mpovtext = mainpovtemplate % (
                imageresolution[0], imageresolution[1], steppovfile, step)
            mpovfile = mainpovfile.format(str(step).zfill(4))
            file(mpovfile, 'w').write(mpovtext)
            cmd = povcomdline.format(mpovfile, stepimgfile, imageresolution[0],
                                     imageresolution[1])
            print()
            print(i, '>>>', cmd)
            print('Image ', step, 'computed ...')
            os.system(cmd)
            if os.path.exists(stepimgfile):
                os.remove(mpovfile)
                os.remove(steppovfile)
                os.remove(bgeomfname)
            else:
                print('Error with image', step)
        else:
            print('Error with image', step)
        step += nbpovprocess
예제 #10
0
파일: postpara.py 프로젝트: pradal/MAppleT
    def run(self, exp_id, batch_dir):
        for date, experiment in self.lpk_files.iteritems():
            ##experiment[str(exp_id)] is the name (including directory) of the
            ##corresponding mtg file
            #mtgp = Mtg_Processing(experiment[str(exp_id)])
            #lstring = mtgp.crt_pseudo_lstring()

            pl = open(experiment[str(exp_id)])
            lstring = cPickle.load(pl)
            pl.close()

            scene = self.bgeom_files[date][str(exp_id)]
            sc = Scene(scene)
            experiment_date = time.strftime(
                "%d/%m/%Y %I:%M:%S",
                time.localtime(
                    os.path.getmtime(self.bgeom_files[date][str(exp_id)])))
            #id_dict = mtgp.crt_envdic()
            print "###########################"

            Viewer.display(sc)
            star = STAR(lstring, sc)
            star.collect(lstring, sc)
            #star.process_shoot(lstring, sc)

            stat = Statistics(lstring=lstring, \
                                attribute_list = [\
                                    "parent_observation",\
                                    "length",\
                                    "radius",\
                                    "leaf_area",\
                                    "leaf_state",\
                                    "ta_pgl",\
                                    "sa_pgl",\
                                    "star_pgl",\
                                    "parent_unit_id",\
                                    "parent_fbr_id",\
                                    "parent_tree_id",\
                                ],\
                                shoot_level = True,\
                                branch_level = True,\
                                tree_level = True,\
                                exp_id = exp_id, \
                                growth_date = date,\
                                exp_date = experiment_date,\
                                dir = batch_dir)

            #Pickle the lstring data structure with information
            lpk = open(batch_dir + str(exp_id) + "_lpk_" + date, "w")
            cPickle.dump(lstring, lpk, 0)
            lpk.close()

            #env = Envelope(id_dict,\
            #                scene,\
            #                output_dir = self.general_directory+date+"_Envelope\\")
            #env.intercept()
            gc.collect()
        gc.collect()
예제 #11
0
    def display(self, degree = None, add = False, randomcolor = True):
        from openalea.plantgl.all import Scene, Shape, Material, FaceSet, Polyline, PointSet, Viewer
        from random import randint
        s = Scene()
        m = Material()
        if degree is None: degree = self.degree
        if degree >= 2:
            try:
                ccw = self.orientation()
            except ValueError:
                ccw = set()

            for fid in self.iterate_over_each_i_cell(2):
                if fid in ccw: ofid = self.alpha(0,fid)
                else: ofid = fid
                positions = []
                for dart, deg in self.orderedorbit_iter(ofid,[0,1]):
                    if deg != 1:
                        positions.append(self.get_position(dart))
                s.add(Shape(FaceSet(positions, [range(len(positions))]) , Material((randint(0,255),randint(0,255),randint(0,255))) if randomcolor else m))
        elif degree == 1:
            for eid in self.iterate_over_each_i_cell(1):
                s.add(Shape(Polyline([self.get_position(eid),self.get_position(self.alpha(0,eid))]) ,Material((randint(0,255),randint(0,255),randint(0,255))) ))
        elif degree == 0:
                s.add(Shape(PointSet([self.get_position(pid) for pid in self.iterate_over_each_i_cell(0)]) ,Material((randint(0,255),randint(0,255),randint(0,255))) ))
        
        
        if add : Viewer.add(s)
        else   : Viewer.display(s)
예제 #12
0
 def load(self, filename):
     """
     :param filename: filename to convert into python object
     :return: a python object interpreted from string "text"
     """
     filename = Path(filename)
     if filename.exists():
         try:
             from openalea.plantgl.all import Scene
             sc = Scene()
             sc.clear()
             sc.read(str(filename), "BGEOM")
             return sc
         except ImportError:
             warnings.warn("You must install PlantGL if you want to load a BGEOM object.")
         except Exception, e:
             print e
             warnings.warn("Impossible to load the scene")
예제 #13
0
def view(patch):
    import itertools

    patchView = Scene()

    opoints = patch.points
    for i0,i1 in [(0,1),(1,2),(0,2)]:
        for index in itertools.product(*[list(range(d)) for d in [opoints.shape[i0],opoints.shape[i1]]]):
            i = [slice(None,None),slice(None,None),slice(None,None)]
            i[i0] = index[0]
            i[i1] = index[1]
            points = opoints[tuple(i)]
            pid = ((i[2]*10000 if not isinstance(i[2],slice) else 0)+
                   (i[1]*100 if not isinstance(i[1],slice) else 0)+
                   (i[0] if not isinstance(i[0],slice) else 0))
            patchView.add(Polyline([p.project() for p in points]))

    return patchView
예제 #14
0
 def display(self, color = [205,205,205], add = False):
   from openalea.plantgl.all import Scene, Shape, Material, FaceSet, Viewer
   from random import randint
   s = Scene()
   for facedart in self.elements(2):
       lastdart = facedart
       positions = []
       for dart in self.orderedorbit(facedart,[0,1]):
           if self.alpha(0, dart) != lastdart:
               positions.append(self.get_position(dart))
           lastdart = dart
       if color is None:
           mat = Material((randint(0,255),randint(0,255),randint(0,255)))
       else:
           mat = Material(tuple(color),diffuse=0.25)
       s.add(Shape(FaceSet(positions, [range(len(positions))]) , mat ))
   if add : Viewer.add(s)
   else : Viewer.display(s)
예제 #15
0
def test_triangle():
    from openalea.plantgl.all import TriangleSet, Scene, Shape, Vector3
    from openalea.plantgl.light import scene_irradiance
    points = [(0, 0, 0), (0, 0, sqrt(2)), (0, sqrt(2), 0)]
    triangles = Scene([Shape(TriangleSet(points, [list(range(3))]), id=8)])

    lights = [(0, 0, 1)]
    res = scene_irradiance(triangles, lights, screenresolution=0.0005)
    print(res)
예제 #16
0
def test_cvxhull():

    leaves = convex()
    s = Scene()
    s += leaves

    hull = cvxHull(leaves)

    s += hull
예제 #17
0
 def save(self, obj, filename):
     """
     Store obj into filename
     """
     filename = Path(filename)
     try:
         from openalea.plantgl.all import Scene
         sc = Scene()
         sc.add(obj)
         return sc.save(str(filename), "BGEOM")
     except ImportError:
         warnings.warn(
             "You must install PlantGL if you want to load a BGEOM object.")
     except Exception, e:
         print e
         warnings.warn(
             "Impossible to save the scene for object %s into %s" %
             (obj, filename))
예제 #18
0
파일: view3d.py 프로젝트: pradal/plantlab
    def defaultScene(self):
        """
        Create a default scene.
        Here she is empty.

        :return: the scene
        """
        scene = Scene()
        return scene
예제 #19
0
    def make_thumbnail(self):
        from .thumbnailmaker import make_thumbnail
        from openalea.plantgl.all import Scene

        if self.gleditor.tree_seleted is None:
            return

        points = self.gleditor.points.subset(
            self.gleditor.segmented_points[self.gleditor.tree_seleted][0])
        return make_thumbnail(Scene([points]), (256, 256))
예제 #20
0
def plot_spline_surface(ctrl_net, points):
    """
    Parameters
    ==========
      - ctrl_net : the net of control points (list of list)
      - points : a set of evaluated points (list of list)
    """

    scene = Scene()
    n = len(points)
    m = len(points[0])

    # Compute a mesh (i.e. TriangleSet) for the set of points
    pointList = [pt for rank in points for pt in rank]
    indexList = []

    for i in range(n - 1):
        for j in range(m - 1):
            ii = i * m + j
            i1 = (ii, ii + 1, ii + m)
            i2 = (ii + 1, ii + m + 1, ii + m)
            indexList.append(i1)
            indexList.append(i2)

    surf = Shape(TriangleSet(pointList, indexList),
                 appearance=Material((12, 125, 12)))
    scene.add(surf)

    # plot the control net
    n = len(ctrl_net)
    m = len(ctrl_net[0])
    for pts in ctrl_net:
        crv = Shape(geometry=Polyline(pts), appearance=Material((125, 12, 12)))
        scene.add(crv)
        for pt in pts:
            scene.add(Shape(Translated(Vector3(pt), Sphere(radius=0.1))))

    for i in range(m):
        pts = [ctrl_net[j][i] for j in range(n)]
        crv = Shape(geometry=Polyline(pts), appearance=Material((12, 12, 125)))
        scene.add(crv)

    Viewer.display(scene)
예제 #21
0
 def load(self, index=0, dir = './adel_saved'):
     from openalea.plantgl.all import Scene
     
     fgeom = dir + '/scene%04d.bgeom'%(index)
     fg = dir + '/adel%04d.pckl'%(index)
     
     s = Scene()
     s.read(fgeom, 'BGEOM')
     geom = {sh.id:sh.geometry for sh in s}
 
     f = open(fg)
     g, TT = pickle.load(f)
     f.close()
     
     self.canopy_age = TT
     
     g.add_property('geometry')
     g.property('geometry').update(geom)
     
     return g, TT
예제 #22
0
def create_scene_from_mtg(mtg,
                          leaf_material=None,
                          stem_material=None,
                          soil_material=None,
                          colors=None):
    """
    Returns a plantgl scene from an mtg.
    """

    if colors is None:
        if leaf_material is None:
            leaf_material = Material(Color3(0, 180, 0))
        if stem_material is None:
            stem_material = Material(Color3(0, 130, 0))
        if soil_material is None:
            soil_material = Material(Color3(170, 85, 0))
            # colors = g.property('color')

    geometries = mtg.property('geometry')
    greeness = mtg.property('is_green')
    labels = mtg.property('label')
    scene = Scene()

    def geom2shape(vid, mesh, scene, colors):
        shape = None
        if isinstance(mesh, list):
            for m in mesh:
                geom2shape(vid, m, scene, colors)
            return
        if mesh is None:
            return
        if isinstance(mesh, Shape):
            shape = mesh
            mesh = mesh.geometry
        label = labels.get(vid)
        is_green = greeness.get(vid)
        if colors:
            shape = Shape(mesh, Material(Color3(*colors.get(vid, [0, 0, 0]))))
        elif not greeness:
            if not shape:
                shape = Shape(mesh)
        elif label.startswith('Stem') and is_green:
            shape = Shape(mesh, stem_material)
        elif label.startswith('Leaf') and is_green:
            shape = Shape(mesh, leaf_material)
        elif not is_green:
            shape = Shape(mesh, soil_material)
        shape.id = vid
        scene.add(shape)

    for vid, mesh in geometries.iteritems():
        geom2shape(vid, mesh, scene, colors)

    return scene
예제 #23
0
def test_boxcounting():
    from openalea.plantgl.all import Scene
    s = Scene()
    s.read('pruning.geom')
    log_n_delta, log_inv_delta, n_delta, delta = boxcounting(s,
                                                             show=False,
                                                             maxd=5)

    try:
        log_n_delta_2, log_inv_delta_2, n_delta, delta_2 = boxcounting(
            s, show=False, maxd=5, library='fractalysis')
        assert log_n_delta == log_n_delta_2
        assert log_inv_delta == log_inv_delta_2
        assert n_delta == n_delta_2
    except:
        pass

    try:
        boxcounting(s, show=False, maxd=5, library='wrong_name')
        assert False
    except:
        assert True
예제 #24
0
    def _render(self, name=None, save=False, max_percentile=None):
        """
        Low level method to render a tissue, colored by concentrations.
        
        Concentrations are taken from the table of concentrations of the 
        Simulation. Uses JetMap as ColorMap.
        
        Parameters
        ----------
            name : string
                Name of the species whose concentrations must be
                rendered
            save : bool
                Whether to save a picture or not
        """

        if name == None:
            array = np.zeros(self.sim.n_cells)
            max_cmap = 0
        else:
            array = self.sim.y.get_species(
                name) / self.sim.dilution_volumes.as_1d_array()
            if max_percentile is None:
                max_cmap = np.max(array)
            else:
                max_cmap = np.percentile(array, max_percentile)
                array = np.where(array <= max_cmap, array,
                                 max_cmap * np.ones(array.shape))
        prop = dict(list(zip(self.sim.cids, array)))
        scene = Scene()
        scene += (guillaume.topomesh_display.drawPropertyTopomesh(
            self.sim.mesh,
            self.sim.get_pos(),
            3,
            prop,
            JetMap,
            color_range=[0., max(max_cmap, 1e-6)],
            coef=0.99,
            transparent_min=False))
        Viewer.display(scene)
        if save:
            timestamp = time.strftime('%Y%m%d_%H%M%S') + "_" + str(
                time.time() * 1000 % 1)[2:]
            Viewer.frameGL.saveImage("figures/" + name + "-" + timestamp +
                                     ".png")
        return max_cmap
예제 #25
0
def color_structures(fruiting_structures, mtg, scene):
    import matplotlib.pyplot as plt
    from openalea.plantgl.all import Material, Shape
    from random import randint, seed
    from numpy.random import seed as nseed
    seed(0)
    nseed(0)
    nbcolors = len(sum([inflos for inflos, gus in fruiting_structures],
                       []))  #len(fruiting_structures)
    _colors = plt.get_cmap('jet', nbcolors)
    colors = lambda x: _colors(x)

    structures = dict()
    idmap = mtg.property('_axial_id')

    print('determine colors')
    colindex = determine_colorindex(fruiting_structures, mtg, scene)
    print(colindex)
    allinflos = [
        lid for vid, lid in list(idmap.items())
        if mtg.label(vid) == 'Inflorescence'
    ]
    for inflos, gus in fruiting_structures:
        i = colindex.pop(0)
        col = colors(i)
        mat = Material([int(c * 100) for c in col[:3]], 2)
        for j in inflos:
            structures[idmap[j]] = mat
        for j in gus:
            structures[idmap[j]] = mat
        print(col, inflos)

    definfmat = Material((50, 50, 50))
    for inf in allinflos:
        if not inf in structures:
            structures[inf] = definfmat

    defmat = Material((0, 0, 0))
    print('compute colored scene')
    nscene = Scene([
        Shape(sh.geometry, structures.get(sh.id, defmat), sh.id, sh.parentId)
        for sh in scene
    ])
    return nscene
    Viewer.display(nsc)
예제 #26
0
def plot_spline_crv(ctrls, pts):
    """ 
    Parameters
    ==========
      - ctrl: control points
      - pts : evaluated points on the curve
    """
    from openalea.plantgl.all import Scene, Shape, Material, FaceSet, Viewer, Polyline
    from random import randint
    scene = Scene()
    crv = Shape(geometry=Polyline(pts), appearance=Material((12, 12, 125)))
    scene.add(crv)

    ctrl = Shape(geometry=Polyline(ctrls), appearance=Material((12, 125, 12)))
    scene.add(ctrl)
    # To complete: Draw the control points and the line between each ones.

    Viewer.display(scene)
예제 #27
0
 def load(self, filename):
     """
     :param filename: filename to convert into python object
     :return: a python object interpreted from string "text"
     """
     filename = Path(filename)
     if filename.exists():
         try:
             from openalea.plantgl.all import Scene
             sc = Scene()
             sc.clear()
             sc.read(str(filename), "BGEOM")
             return sc
         except ImportError:
             warnings.warn(
                 "You must install PlantGL if you want to load a BGEOM object."
             )
         except Exception, e:
             print e
             warnings.warn("Impossible to load the scene")
예제 #28
0
파일: sim.py 프로젝트: pradal/hydroshoot
# =============================================================================
# Construct the plant mock-up
# =============================================================================

# Path for plant digitalization data.
g = architecture.vine_mtg('digit.input')

# Local Coordinates Correction
for v in traversal.iter_mtg2(g, g.root):
    architecture.vine_phyto_modular(g, v)
    architecture.vine_petiole(g, v, pet_ins=90., pet_ins_cv=0.,
                              phyllo_angle=180)
    architecture.vine_leaf(g, v, leaf_inc=-45., leaf_inc_cv=100., lim_max=12.5,
                           lim_min=5., order_lim_max=6., max_order=55,
                           rand_rot_angle=90., cordon_vector=None)
    architecture.vine_mtg_properties(g, v)
    architecture.vine_mtg_geometry(g, v)
    architecture.vine_transform(g, v)

# Display of the plant mock-up (result in 'fig_01_plant_mock_up.png')
# scene = HSVisu.visu(g,def_elmnt_color_dict=True,scene=Scene(),
#                    snap_shot_path='mockup.png')
scene = display.visu(g, def_elmnt_color_dict=True, scene=Scene(),
                     view_result=True)

# =============================================================================
# Run HydroShoot
# =============================================================================

model.run(g, str(getcwd()) + '/', scene)
예제 #29
0
                            N_max_order=6)
    architecture.vine_petiole(g,
                              v,
                              pet_ins=90.,
                              pet_ins_cv=0.,
                              phyllo_angle=180.)
    architecture.vine_leaf(g,
                           v,
                           leaf_inc=-45.,
                           leaf_inc_cv=100.,
                           lim_max=12.5,
                           lim_min=5.,
                           order_lim_max=6,
                           max_order=55,
                           rand_rot_angle=90.,
                           cordon_vector=None)
    architecture.vine_mtg_properties(g, v)
    architecture.vine_mtg_geometry(g, v)
    architecture.vine_transform(g, v)

scene = display.visu(g,
                     def_elmnt_color_dict=True,
                     scene=Scene(),
                     view_result=True)

# =============================================================================
# Run HydroShoot
# =============================================================================

model.run(g, str(getcwd()) + '/', scene)
예제 #30
0
def run(g, wd, scene=None, write_result=True, **kwargs):
    """
    Calculates leaf gas and energy exchange in addition to the hydraulic structure of an individual plant.

    :Parameters:
    - **g**: a multiscale tree graph object
    - **wd**: string, working directory
    - **scene**: PlantGl scene
    - **kwargs** can include:
        - **psi_soil**: [MPa] predawn soil water potential
        - **gdd_since_budbreak**: [°Cd] growing degree-day since bubreak
        - **sun2scene**: PlantGl scene, when prodivided, a sun object (sphere) is added to it
        - **soil_size**: [cm] length of squared mesh size
    """
    print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
    print('+ Project: ', wd)
    print('++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++')
    time_on = datetime.now()

    # Read user parameters
    params_path = wd + 'params.json'
    params = Params(params_path)

    output_index = params.simulation.output_index

    # ==============================================================================
    # Initialisation
    # ==============================================================================
    #   Climate data
    meteo_path = wd + params.simulation.meteo
    meteo_tab = read_csv(meteo_path, sep=';', decimal='.', header=0)
    meteo_tab.time = DatetimeIndex(meteo_tab.time)
    meteo_tab = meteo_tab.set_index(meteo_tab.time)

    #   Adding missing data
    if 'Ca' not in meteo_tab.columns:
        meteo_tab['Ca'] = [400.] * len(meteo_tab)  # ppm [CO2]
    if 'Pa' not in meteo_tab.columns:
        meteo_tab['Pa'] = [101.3] * len(meteo_tab)  # atmospheric pressure

    #   Determination of the simulation period
    sdate = datetime.strptime(params.simulation.sdate, "%Y-%m-%d %H:%M:%S")
    edate = datetime.strptime(params.simulation.edate, "%Y-%m-%d %H:%M:%S")
    datet = date_range(sdate, edate, freq='H')
    meteo = meteo_tab.loc[datet, :]
    time_conv = {'D': 86.4e3, 'H': 3600., 'T': 60., 'S': 1.}[datet.freqstr]

    # Reading available pre-dawn soil water potential data
    if 'psi_soil' in kwargs:
        psi_pd = DataFrame([kwargs['psi_soil']] * len(meteo.time),
                           index=meteo.time, columns=['psi'])
    else:
        assert (isfile(wd + 'psi_soil.input')), "The 'psi_soil.input' file is missing."
        psi_pd = read_csv(wd + 'psi_soil.input', sep=';', decimal='.').set_index('time')
        psi_pd.index = [datetime.strptime(s, "%Y-%m-%d") for s in psi_pd.index]

    # Unit length conversion (from scene unit to the standard [m]) unit)
    unit_scene_length = params.simulation.unit_scene_length
    length_conv = {'mm': 1.e-3, 'cm': 1.e-2, 'm': 1.}[unit_scene_length]

    # Determination of cumulative degree-days parameter
    t_base = params.phenology.t_base
    budbreak_date = datetime.strptime(params.phenology.emdate, "%Y-%m-%d %H:%M:%S")

    if 'gdd_since_budbreak' in kwargs:
        gdd_since_budbreak = kwargs['gdd_since_budbreak']
    elif min(meteo_tab.index) <= budbreak_date:
        tdays = date_range(budbreak_date, sdate, freq='D')
        tmeteo = meteo_tab.loc[tdays, :].Tac.to_frame()
        tmeteo = tmeteo.set_index(DatetimeIndex(tmeteo.index).normalize())
        df_min = tmeteo.groupby(tmeteo.index).aggregate(np.min).Tac
        df_max = tmeteo.groupby(tmeteo.index).aggregate(np.max).Tac
        # df_tt = merge(df_max, df_min, how='inner', left_index=True, right_index=True)
        # df_tt.columns = ('max', 'min')
        # df_tt['gdd'] = df_tt.apply(lambda x: 0.5 * (x['max'] + x['min']) - t_base)
        # gdd_since_budbreak = df_tt['gdd'].cumsum()[-1]
        df_tt = 0.5 * (df_min + df_max) - t_base
        gdd_since_budbreak = df_tt.cumsum()[-1]
    else:
        raise ValueError('Cumulative degree-days temperature is not provided.')

    print('GDD since budbreak = %d °Cd' % gdd_since_budbreak)

    # Determination of perennial structure arms (for grapevine)
    # arm_vid = {g.node(vid).label: g.node(vid).components()[0]._vid for vid in g.VtxList(Scale=2) if
    #            g.node(vid).label.startswith('arm')}

    # Soil reservoir dimensions (inter row, intra row, depth) [m]
    soil_dimensions = params.soil.soil_dimensions
    soil_total_volume = soil_dimensions[0] * soil_dimensions[1] * soil_dimensions[2]
    rhyzo_coeff = params.soil.rhyzo_coeff
    rhyzo_total_volume = rhyzo_coeff * np.pi * min(soil_dimensions[:2]) ** 2 / 4. * soil_dimensions[2]

    # Counter clockwise angle between the default X-axis direction (South) and
    # the real direction of X-axis.
    scene_rotation = params.irradiance.scene_rotation

    # Sky and cloud temperature [degreeC]
    t_sky = params.energy.t_sky
    t_cloud = params.energy.t_cloud

    # Topological location
    latitude = params.simulation.latitude
    longitude = params.simulation.longitude
    elevation = params.simulation.elevation
    geo_location = (latitude, longitude, elevation)

    # Pattern
    ymax, xmax = map(lambda dim: dim / length_conv, soil_dimensions[:2])
    pattern = ((-xmax / 2.0, -ymax / 2.0), (xmax / 2.0, ymax / 2.0))

    # Label prefix of the collar internode
    vtx_label = params.mtg_api.collar_label

    # Label prefix of the leaves
    leaf_lbl_prefix = params.mtg_api.leaf_lbl_prefix

    # Label prefices of stem elements
    stem_lbl_prefix = params.mtg_api.stem_lbl_prefix

    E_type = params.irradiance.E_type
    tzone = params.simulation.tzone
    turtle_sectors = params.irradiance.turtle_sectors
    icosphere_level = params.irradiance.icosphere_level
    turtle_format = params.irradiance.turtle_format

    energy_budget = params.simulation.energy_budget
    print('Energy_budget: %s' % energy_budget)

    # Optical properties
    opt_prop = params.irradiance.opt_prop

    print('Hydraulic structure: %s' % params.simulation.hydraulic_structure)

    psi_min = params.hydraulic.psi_min

    # Parameters of leaf Nitrogen content-related models
    Na_dict = params.exchange.Na_dict

    # Computation of the form factor matrix
    form_factors = None
    if energy_budget:
        print('Computing form factors...')
        form_factors = energy.form_factors_simplified(
            g, pattern=pattern, infinite=True, leaf_lbl_prefix=leaf_lbl_prefix, turtle_sectors=turtle_sectors,
            icosphere_level=icosphere_level, unit_scene_length=unit_scene_length)

    # Soil class
    soil_class = params.soil.soil_class
    print('Soil class: %s' % soil_class)

    # Rhyzosphere concentric radii determination
    rhyzo_radii = params.soil.rhyzo_radii
    rhyzo_number = len(rhyzo_radii)

    # Add rhyzosphere elements to mtg
    rhyzo_solution = params.soil.rhyzo_solution
    print('rhyzo_solution: %s' % rhyzo_solution)

    if rhyzo_solution:
        if not any(item.startswith('rhyzo') for item in g.property('label').values()):
            vid_collar = architecture.mtg_base(g, vtx_label=vtx_label)
            vid_base = architecture.add_soil_components(g, rhyzo_number, rhyzo_radii,
                                                        soil_dimensions, soil_class, vtx_label)
        else:
            vid_collar = g.node(g.root).vid_collar
            vid_base = g.node(g.root).vid_base

            radius_prev = 0.

            for ivid, vid in enumerate(g.Ancestors(vid_collar)[1:]):
                radius = rhyzo_radii[ivid]
                g.node(vid).Length = radius - radius_prev
                g.node(vid).depth = soil_dimensions[2] / length_conv  # [m]
                g.node(vid).TopDiameter = radius * 2.
                g.node(vid).BotDiameter = radius * 2.
                g.node(vid).soil_class = soil_class
                radius_prev = radius

    else:
        # Identifying and attaching the base node of a single MTG
        vid_collar = architecture.mtg_base(g, vtx_label=vtx_label)
        vid_base = vid_collar

    g.node(g.root).vid_base = vid_base
    g.node(g.root).vid_collar = vid_collar

    # Initializing sapflow to 0
    for vtx_id in traversal.pre_order2(g, vid_base):
        g.node(vtx_id).Flux = 0.

    # Addition of a soil element
    if 'Soil' not in g.properties()['label'].values():
        if 'soil_size' in kwargs:
            if kwargs['soil_size'] > 0.:
                architecture.add_soil(g, kwargs['soil_size'])
        else:
            architecture.add_soil(g, 500.)

    # Suppression of undesired geometry for light and energy calculations
    geom_prop = g.properties()['geometry']
    vidkeys = []
    for vid in g.properties()['geometry']:
        n = g.node(vid)
        if not n.label.startswith(('L', 'other', 'soil')):
            vidkeys.append(vid)
    [geom_prop.pop(x) for x in vidkeys]
    g.properties()['geometry'] = geom_prop

    # Attaching optical properties to MTG elements
    g = irradiance.optical_prop(g, leaf_lbl_prefix=leaf_lbl_prefix,
                                stem_lbl_prefix=stem_lbl_prefix, wave_band='SW',
                                opt_prop=opt_prop)

    # Estimation of Nitroen surface-based content according to Prieto et al. (2012)
    # Estimation of intercepted irradiance over past 10 days:
    if not 'Na' in g.property_names():
        print('Computing Nitrogen profile...')
        assert (sdate - min(
            meteo_tab.index)).days >= 10, 'Meteorological data do not cover 10 days prior to simulation date.'

        ppfd10_date = sdate + timedelta(days=-10)
        ppfd10t = date_range(ppfd10_date, sdate, freq='H')
        ppfd10_meteo = meteo_tab.loc[ppfd10t, :]
        caribu_source, RdRsH_ratio = irradiance.irradiance_distribution(ppfd10_meteo, geo_location, E_type,
                                                                        tzone, turtle_sectors, turtle_format,
                                                                        None, scene_rotation, None)

        # Compute irradiance interception and absorbtion
        g, caribu_scene = irradiance.hsCaribu(mtg=g,
                                              unit_scene_length=unit_scene_length,
                                              source=caribu_source, direct=False,
                                              infinite=True, nz=50, ds=0.5,
                                              pattern=pattern)

        g.properties()['Ei10'] = {vid: g.node(vid).Ei * time_conv / 10. / 1.e6 for vid in g.property('Ei').keys()}

        # Estimation of leaf surface-based nitrogen content:
        for vid in g.VtxList(Scale=3):
            if g.node(vid).label.startswith(leaf_lbl_prefix):
                g.node(vid).Na = exchange.leaf_Na(gdd_since_budbreak, g.node(vid).Ei10,
                                                  Na_dict['aN'],
                                                  Na_dict['bN'],
                                                  Na_dict['aM'],
                                                  Na_dict['bM'])

    # Define path to folder
    output_path = wd + 'output' + output_index + '/'

    # Save geometry in an external file
    # HSArc.mtg_save_geometry(scene, output_path)

    # ==============================================================================
    # Simulations
    # ==============================================================================

    sapflow = []
    # sapEast = []
    # sapWest = []
    an_ls = []
    rg_ls = []
    psi_stem = {}
    Tlc_dict = {}
    Ei_dict = {}
    an_dict = {}
    gs_dict = {}

    # The time loop +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    for date in meteo.time:
        print("=" * 72)
        print('Date', date, '\n')

        # Select of meteo data
        imeteo = meteo[meteo.time == date]

        # Add a date index to g
        g.date = datetime.strftime(date, "%Y%m%d%H%M%S")

        # Read soil water potntial at midnight
        if 'psi_soil' in kwargs:
            psi_soil = kwargs['psi_soil']
        else:
            if date.hour == 0:
                try:
                    psi_soil_init = psi_pd.loc[date, :][0]
                    psi_soil = psi_soil_init
                except KeyError:
                    pass
            # Estimate soil water potntial evolution due to transpiration
            else:
                psi_soil = hydraulic.soil_water_potential(psi_soil,
                                                          g.node(vid_collar).Flux * time_conv,
                                                          soil_class, soil_total_volume, psi_min)

        if 'sun2scene' not in kwargs or not kwargs['sun2scene']:
            sun2scene = None
        elif kwargs['sun2scene']:
            sun2scene = display.visu(g, def_elmnt_color_dict=True, scene=Scene())

        # Compute irradiance distribution over the scene
        caribu_source, RdRsH_ratio = irradiance.irradiance_distribution(imeteo, geo_location, E_type, tzone,
                                                                        turtle_sectors, turtle_format, sun2scene,
                                                                        scene_rotation, None)

        # Compute irradiance interception and absorbtion
        g, caribu_scene = irradiance.hsCaribu(mtg=g,
                                              unit_scene_length=unit_scene_length,
                                              source=caribu_source, direct=False,
                                              infinite=True, nz=50, ds=0.5,
                                              pattern=pattern)

        # g.properties()['Ei'] = {vid: 1.2 * g.node(vid).Ei for vid in g.property('Ei').keys()}

        # Trace intercepted irradiance on each time step
        rg_ls.append(sum([g.node(vid).Ei / (0.48 * 4.6) * surface(g.node(vid).geometry) * (length_conv ** 2) \
                          for vid in g.property('geometry') if g.node(vid).label.startswith('L')]))

        # Hack forcing of soil temperture (model of soil temperature under development)
        t_soil = energy.forced_soil_temperature(imeteo)

        # Climatic data for energy balance module
        # TODO: Change the t_sky_eff formula (cf. Gliah et al., 2011, Heat and Mass Transfer, DOI: 10.1007/s00231-011-0780-1)
        t_sky_eff = RdRsH_ratio * t_cloud + (1 - RdRsH_ratio) * t_sky

        solver.solve_interactions(g, imeteo, psi_soil, t_soil, t_sky_eff,
                                  vid_collar, vid_base, length_conv, time_conv,
                                  rhyzo_total_volume, params, form_factors)

        # Write mtg to an external file
        if scene is not None:
            architecture.mtg_save(g, scene, output_path)

        # Plot stuff..
        sapflow.append(g.node(vid_collar).Flux)
        # sapEast.append(g.node(arm_vid['arm1']).Flux)
        # sapWest.append(g.node(arm_vid['arm2']).Flux)

        an_ls.append(g.node(vid_collar).FluxC)

        psi_stem[date] = deepcopy(g.property('psi_head'))
        Tlc_dict[date] = deepcopy(g.property('Tlc'))
        Ei_dict[date] = deepcopy(g.property('Eabs'))
        an_dict[date] = deepcopy(g.property('An'))
        gs_dict[date] = deepcopy(g.property('gs'))

        print('---------------------------')
        print('psi_soil', round(psi_soil, 4))
        print('psi_collar', round(g.node(3).psi_head, 4))
        print('psi_leaf', round(np.median([g.node(vid).psi_head for vid in g.property('gs').keys()]), 4))
        print('')
        # print('Rdiff/Rglob ', RdRsH_ratio)
        # print('t_sky_eff ', t_sky_eff)
        print('gs', np.median(list(g.property('gs').values())))
        print('flux H2O', round(g.node(vid_collar).Flux * 1000. * time_conv, 4))
        print('flux C2O', round(g.node(vid_collar).FluxC, 4))
        print('Tleaf ', round(np.median([g.node(vid).Tlc for vid in g.property('gs').keys()]), 2),
              'Tair ', round(imeteo.Tac[0], 4))
        print('')
        print("=" * 72)

    # End time loop +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    # Write output
    # Plant total transpiration
    sapflow = [flow * time_conv * 1000. for flow in sapflow]

    # sapEast, sapWest = [np.array(flow) * time_conv * 1000. for i, flow in enumerate((sapEast, sapWest))]

    # Median leaf temperature
    t_ls = [np.median(list(Tlc_dict[date].values())) for date in meteo.time]

    # Intercepted global radiation
    rg_ls = np.array(rg_ls) / (soil_dimensions[0] * soil_dimensions[1])

    results_dict = {
        'Rg': rg_ls,
        'An': an_ls,
        'E': sapflow,
        # 'sapEast': sapEast,
        # 'sapWest': sapWest,
        'Tleaf': t_ls
    }

    # Results DataFrame
    results_df = DataFrame(results_dict, index=meteo.time)

    # Write
    if write_result:
        results_df.to_csv(output_path + 'time_series.output',
                          sep=';', decimal='.')

    time_off = datetime.now()

    print("")
    print("beg time", time_on)
    print("end time", time_off)
    print("--- Total runtime: %d minute(s) ---" % int((time_off - time_on).seconds / 60.))

    return results_df
예제 #31
0
def build_scene(mtg,
                position=(0, 0, 0),
                orientation=0,
                leaf_material=None,
                stem_material=None,
                soil_material=None,
                colors=None):
    """
    Returns a plantgl scene from an mtg.
    """
    if not isinstance(mtg, list):
        mtg = [mtg]
    if not isinstance(position, list):
        position = [position]
    if not isinstance(orientation, list):
        orientation = [orientation]
    if colors is None:
        if leaf_material is None:
            leaf_material = Material(Color3(0, 180, 0))
        if stem_material is None:
            stem_material = Material(Color3(0, 130, 0))
        if soil_material is None:
            soil_material = Material(Color3(170, 85, 0))
            # colors = g.property('color')

    scene = Scene()

    def geom2shape(vid,
                   mesh,
                   scene,
                   colors,
                   position,
                   orientation,
                   shape_id=None):
        shape = None
        if shape_id is None:
            shape_id = vid
        if isinstance(mesh, list):
            for m in mesh:
                geom2shape(vid, m, scene, colors, position, orientation)
            return
        if mesh is None:
            return
        if isinstance(mesh, Shape):
            shape = mesh
            mesh = mesh.geometry
        label = labels.get(vid)
        is_green = greeness.get(vid)
        mesh = Translated(position, AxisRotated((0, 0, 1), orientation, mesh))
        if colors:
            shape = Shape(mesh, Material(Color3(*colors.get(vid, [0, 0, 0]))))
        elif not greeness:
            if not shape:
                shape = Shape(mesh)
        elif label.startswith('Stem') and is_green:
            shape = Shape(mesh, stem_material)
        elif label.startswith('Leaf') and is_green:
            shape = Shape(mesh, leaf_material)
        elif not is_green:
            shape = Shape(mesh, soil_material)
        shape.id = shape_id

        scene.add(shape)

    nump = []
    count = 0
    for i, (g, p, o) in enumerate(zip(cycle(mtg), position,
                                      cycle(orientation))):
        geometries = g.property('geometry')
        greeness = g.property('is_green')
        labels = g.property('label')

        for vid, mesh in geometries.items():
            geom2shape(vid, mesh, scene, colors, p, o, vid + count)
            nump.append(i)
        count += len(g)

    return scene, nump
예제 #32
0
파일: util.py 프로젝트: thkhavi/scanalea
def plot(g):
    return Scene(g.property('geometry').values())
예제 #33
0
파일: py_mtg.py 프로젝트: openalea/mtg
def py_Linetree2Scene(lt, scale="Micro"):
    id = Extract(lt, SceneId=scale)
    if id == 0:
        return None
    return Scene(Scene.pool().get(id))
예제 #34
0
    def run(self, exp_id, batch_dir):
        for date, experiment in self.lpk_files.iteritems():
            ##experiment[str(exp_id)] is the name (including directory) of the
            ##corresponding mtg file
            #mtgp = Mtg_Processing(experiment[str(exp_id)])
            #lstring = mtgp.crt_pseudo_lstring()

            pl = open(experiment[str(exp_id)])
            lstring = cPickle.load(pl)
            pl.close()

            fbr_id_add = 100000000
            unit_id_add = 1000000
            id_dicts = [{}, {}, {}]
            print len(lstring)

            for i in range(len(lstring)):
                if lstring[i][0].parent_tree_id == 0:
                    new_fbr_id = lstring[i][0].parent_fbr_id + fbr_id_add
                    new_unit_id = lstring[i][0].parent_unit_id + unit_id_add
                    #If this element has not been processed yet
                    #Note that id_dicts[2] is a list, so do not use
                    #      i not in id_dicts[2].values
                    #ALSO: the selected metamer should have a leaf!
                    #OTHERWISE it could cause errors when using envelope
                    if i not in id_dicts[2] and lstring[i][0].leaf_area > 0:
                        ##If the growth unit is a floral one, then consider
                        ##it as part of the one before it
                        #if lstring[i][0].parent_observation == "floral":
                        #    new_unit_id -= 1
                        #If the new_unit_id has already been there
                        if new_unit_id in id_dicts[2].keys():
                            #Then only add the metamer id
                            id_dicts[2][new_unit_id].append(i)
                        #If the new_unit_id is not there
                        else:
                            id_dicts[2].update({new_unit_id: [i]})
                            #If the new_fbr_id has already been there
                            if new_fbr_id in id_dicts[1].keys():
                                #Then only add the new_unit_id
                                id_dicts[1][new_fbr_id].append(new_unit_id)
                            else:
                                id_dicts[1].update({new_fbr_id: [new_unit_id]})
                                #If the tree has been there already
                                if lstring[i][0].parent_tree_id in id_dicts[
                                        0].keys():
                                    #Then only add the new_fbr_id
                                    id_dicts[0][0].append(new_fbr_id)
                                else:
                                    id_dicts[0].update({0: [new_fbr_id]})
                    else:
                        continue
                else:
                    continue

            #This is the remove the cases where one growth
            #unit only has one leaf
            for k in id_dicts[2].keys():
                if len(id_dicts[2][k]) <= 1:
                    print k
                    id_dicts[2].pop(k)
                    for t in id_dicts[1].keys():
                        if k in id_dicts[1][t]:
                            id_dicts[1][t].remove(k)
                            if len(id_dicts[1][t]) == 0:
                                id_dicts[1].pop(t)
                                for r in id_dicts[0].keys():
                                    if t in id_dicts[0][r]:
                                        id_dicts[0][r].remove(t)
                                        if len(id_dicts[0][r]) == 0:
                                            id_dicts[0].pop(r)

            print "-----------------------------------------------------"

            idd_pk = open(batch_dir + str(exp_id) + "_" + date + "_" + ".idpk",
                          "w")
            cPickle.dump(id_dicts, idd_pk, 0)
            idd_pk.close()

            idd_print = open(
                batch_dir + str(exp_id) + "_" + date + "_" + ".txt", "w")
            for d in id_dicts:
                for k, v in d.iteritems():
                    idd_print.write("{0}------{1}\n\n".format(k, v))
                idd_print.write("####################\n\n")
            idd_print.close()

            scene = self.bgeom_files[date][str(exp_id)]
            sc = Scene(scene)
            experiment_date = time.strftime(
                "%d/%m/%Y %I:%M:%S",
                time.localtime(
                    os.path.getmtime(self.bgeom_files[date][str(exp_id)])))
            IntegratedMultiScaleStar(str(exp_id),
                                     sc,
                                     id_dicts,
                                     growth_date=date,
                                     distrib=[['R', 'R', 'R'], ['A', 'R', 'R'],
                                              ['A', 'A', 'R'], ['A', 'A',
                                                                'A']],
                                     save_pth=batch_dir,
                                     eid=exp_id)
            #nn is the new name for the package with envelope scenes and
            nn = str(exp_id) + "_" + date
            os.rename(str(exp_id), nn)
            #id_dict = mtgp.crt_envdic()
            print "###########################"

            gc.collect()
        gc.collect()
예제 #35
0
 def make_thumbnail():
     from .thumbnailmaker import make_thumbnail
     from openalea.plantgl.all import Scene
     return make_thumbnail(Scene([self.mtgeditor.points]),
                           (256, 256))
예제 #36
0
파일: test.py 프로젝트: pradal/lignum
    g = xml2mtg(fn)
    gs.append(g)

# Compute Color
lut = {}
lut[0] = (255, 110,50)
lut[1] = (0,255,0)
lut[2] = (0,0,255)
for g in gs:
    ct = g.property('LGAtype')
    _colors = dict((v, lut.get(int(x),(0,127,127))) for v, x in ct.iteritems())
    g.properties()['color'] = _colors
    labels = g.property('label')
    for v, label in labels.iteritems():
        if label == 'Bud':
            _colors[v] = _colors[g.parent(v)]

# Compute scenes
scenes = []
i= 0
for g in gs:
    scene = lignum_turtle(g, has_color=True)
    scenes.append(scene)

# Merge scenes

scene = Scene()
for sc in scenes:
    scene.merge(sc)

예제 #37
0
파일: py_mtg.py 프로젝트: VirtualPlants/AML
def py_Linetree2Scene(lt,scale = 'Micro'):
    id = Extract(lt,SceneId=scale)
    if id == 0:
        return None
    return Scene(Scene.pool().get(id))
예제 #38
0
    for distance in distances:
        fs = fsm.determine_fruiting_structure(mtg,
                                              cycle=cycle,
                                              fruit_distance=distance)
        print()
        print('Nb of groups', len(fs))
        #lfr = leaf_fruit_ratio(mtg, fs)
        #print [l/float(f) for l,f in lfr]
        #print np.mean([l/float(f) for l,f in lfr])
        nbgus = [len(gus) for inflos, gus in fs]
        #print nbgus
        print(np.mean(nbgus), np.std(nbgus))

        radii = [max([params[gu].radius for gu in gus]) for inflos, gus in fs]
        #print radii
        print(np.mean(radii), np.std(radii))

    #fs = applymodel(mtg, 3, int(sys.argv[1]) if len(sys.argv) > 1 else 3)
    colorrepresentation = False
    if colorrepresentation:
        sc = Scene('structure-cycle' + str(cycle) + ('b' if lowres else '') +
                   '.bgeom')
        print('Start coloring')
        nsc = color_structures(fs, mtg, sc)
        print('End coloring')
        nsc.save('structure-cycle' + str(cycle) + '-dist' + str(distance) +
                 '.bgeom')
        #Viewer.display(nsc)
        nsc.save('structure-cycle' + str(cycle) + '-dist' + str(distance) +
                 '-core.pov')