def cones(obj, **kwds): X_attr = kwds.get('X_attr', 'X') Y_attr = kwds.get('Y_attr', 'Y') pos_dist = kwds.get('dist', 'Distance') pos_az = kwds.get('az', 'Azimuth') circ_attr = kwds.get('circ_attr', 'Circonference') height_attr = kwds.get('height_attr', 'Haut') botHoup_attr = kwds.get('botHoup', 'BaseHoup') radiusHoup_prefix = kwds.get('radiusHoup_prefix', 'r_houp') radiusHoup = kwds.get('radiusHoup', None) wood = kwds.get('wood', True) rgb = kwds.get('rgb', None) spec_name = kwds.get('spec_name', 'houppier_mat') if not obj.__dict__.has_key("posX") and not obj.__dict__.has_key("posY"): try: r = obj.__dict__[pos_dist] a = obj.__dict__[pos_az] obj.posX = r * cos(radians(forest2geomAZ(a))) obj.posY = r * sin(radians(forest2geomAZ(a))) except KeyError: obj.posX = obj.__dict__[X_attr] obj.posY = obj.__dict__[Y_attr] ht = 100 * (obj.__dict__[height_attr] - obj.__dict__[botHoup_attr]) rd_kz = [k for k in obj.__dict__.keys() if radiusHoup_prefix in k] radii = [obj.__dict__[k] for k in rd_kz] if radiusHoup: if radiusHoup == 'Max': cone_radius = 1.0 * max(radii) else: cone_radius = obj.__dict__[radiusHoup] else: cone_radius = 1.0 * sum(radii) / len(radii) #cone_radius = ht/2. h = pgl.Translated( pgl.Vector3(obj.posX, obj.posY, obj.__dict__[botHoup_attr] * 100), pgl.Cone(cone_radius, ht, 1, 12)) tr = pgl.Translated( pgl.Vector3(obj.posX, obj.posY, 0), pgl.Cylinder(obj.__dict__[circ_attr] / (2 * pi), obj.__dict__[botHoup_attr] * 100 + ht * 0.1)) if rgb == None: s_h = pgl.Shape(h, stand_material(spec_name=spec_name)) else: r, g, b = rgb s_h = pgl.Shape(h, stand_material(r, g, b, spec_name)) s_tr = pgl.Shape( tr, stand_material(spec_name="trunk_mat"), ) # s_h.id*10 ) if wood: return (s_h, s_tr) else: return (s_h, )
def display(vertices, faces, color=None, view=True): """3D display of a polyhedron with PlantGL Args: vertices (list of tuples): list of 3D coordinates of polyhedron vertices faces (list of tuple): list of vertex indices defining the faces color: a (r,g,b) tuple defining color. If None (default), default PlantGL material is used. view (bool): should the shape be displayed ? Returns: a pgl shape """ global display_enable if display_enable: if color is None: shape = pgl.Shape(pgl.FaceSet(pointList=vertices, indexList=faces)) else: m = pgl.Material(pgl.Color3(*color)) shape = pgl.Shape(pgl.FaceSet(pointList=vertices, indexList=faces), m) if view: pgl.Viewer.display(shape) else: warnings.warn('PlantGL not installed: display is not enable!') shape = None return shape
def build_scene(self, leaf_material=None, stem_material=None, soil_material=None): if not leaf_material: leaf_material = pgl.Material(pgl.Color3(0, 180, 0)) if not stem_material: stem_material = pgl.Material(pgl.Color3(0, 130, 0)) if not soil_material: soil_material = pgl.Material(pgl.Color3(170, 85, 0)) scene = pgl.Scene() for id, plant in self.plants.items(): leaves = plant["leaves"] stems = plant["stems"] for lid, leaf in leaves.items(): shape = pgl.Shape(leaf, leaf_material) shape.name = str(lid) scene.add(shape) if len(stems.pointList) > 0: shape = pgl.Shape(stems, stem_material) shape.name = str(id) scene.add(shape) if "soil" in self.soil: shape = pgl.Shape(self.soil["soil"], soil_material) scene.add(shape) self.scene = scene
def to_scene(self, conversion=1.0, name=None): r"""Create a PlantGL scene from a Ply dictionary. Args: conversion (float, optional): Conversion factor that should be applied to the vertices. Defaults to 1.0. name (str, optional): Name that should be given to the created PlantGL symbol. Defaults to None and is ignored. Returns: """ import openalea.plantgl.all as pgl smb_class, args, kwargs = self.to_geom_args(conversion=conversion, name=name) smb = smb_class(*args, **kwargs) if name is not None: smb.setName(name) if self.get('material', None) is not None: mat = pgl.Material(self['material']) shp = pgl.Shape(smb, mat) else: shp = pgl.Shape(smb) if name is not None: shp.setName(name) scn = pgl.Scene([shp]) return scn
def view_kdtree(kdtree, bbox=[[-1., 1.], [-1., 1.], [-1., 1.]], radius=0.05): import numpy as np scene = pgl.Scene() sphere = pgl.Sphere(radius, slices=16, stacks=16) silver = pgl.Material(ambient=(49, 49, 49), diffuse=3., specular=(129, 129, 129), shininess=0.4) gold = pgl.Material(ambient=(63, 50, 18), diffuse=3., specular=(160, 141, 93), shininess=0.4) if isinstance(kdtree, KDNode): dim = kdtree.axis plane_bbox = [b for i, b in enumerate(bbox) if i != dim] plane_points = [] plane_points += [ np.insert([plane_bbox[0][0], plane_bbox[1][0]], dim, kdtree.pivot[dim]) ] plane_points += [ np.insert([plane_bbox[0][0], plane_bbox[1][1]], dim, kdtree.pivot[dim]) ] plane_points += [ np.insert([plane_bbox[0][1], plane_bbox[1][1]], dim, kdtree.pivot[dim]) ] plane_points += [ np.insert([plane_bbox[0][1], plane_bbox[1][0]], dim, kdtree.pivot[dim]) ] left_bbox = np.copy(bbox).astype(float) right_bbox = np.copy(bbox).astype(float) left_bbox[dim, 1] = kdtree.pivot[dim] right_bbox[dim, 0] = kdtree.pivot[dim] scene += pgl.Shape(pgl.Translated(kdtree.pivot, sphere), gold) scene += view_kdtree(kdtree.left_child, bbox=left_bbox, radius=radius) scene += view_kdtree(kdtree.right_child, bbox=right_bbox, radius=radius) # scene += pgl.Shape(pgl.Polyline(plane_points+[plane_points[0]],width=2),pgl.Material(ambient=(0,0,0))) scene += pgl.Shape( pgl.Polyline(plane_points + [plane_points[0]], width=2), pgl.Material(ambient=tuple(list(np.insert([0, 0], dim, 255))))) scene += pgl.Shape(pgl.FaceSet(plane_points, [range(4)]), pgl.Material(ambient=(0, 0, 0), transparency=0.6)) else: assert (type(kdtree) == list) or (isinstance(kdtree, np.ndarray)) for p in kdtree: scene += pgl.Shape(pgl.Translated(p, sphere), silver) return scene
def stand_box(domain): ''' domain: 3D bounding box of the stand ''' # list of points z_base = domain[0][2] z_top = domain[1][2] sides_points = [ domain[0], # coordinates of bottom right corner (domain[1][0], domain[0][1], z_base), (domain[1][0], domain[1][1], z_base), # coordinates of bottom left corner (domain[0][0], domain[1][1], z_base), (domain[0][0], domain[0][1], z_top), # coordinates of top right corner (domain[1][0], domain[0][1], z_top), (domain[1][0], domain[1][1], z_top), # coordinates of top left corner (domain[0][0], domain[1][1], z_top) ] bottom_points = [ domain[0], # coordinates of bottom right corner (domain[1][0], domain[0][1], z_base), (domain[1][0], domain[1][1], z_base), # coordinates of bottom left corner (domain[0][0], domain[1][1], z_base) ] # list of indices to make the quads of the sides from the points side_indices = [ (0, 1, 5, 4), # (1, 2, 6, 5), # indices for (2, 3, 7, 6), # side faces (3, 0, 4, 7) ] # # list of indices to make the quads of the bottom from the points bottom_indices = [(0, 1, 2, 3)] # indices for bottom face # list of colors side_color = pgl.Color3(0, 0, 0) bottom_color = pgl.Color3(255, 255, 255) # construction of the geometry for the sides side_box = pgl.QuadSet(sides_points, side_indices) # construction of the geometry for the bottom bottom_box = pgl.QuadSet(bottom_points, bottom_indices) # create 2 shapes: 1 with side_color, 1 with bottom_color sides_shape = pgl.Shape(side_box, pgl.Material(side_color)) bottom_shape = pgl.Shape(bottom_box, pgl.Material(bottom_color)) scene = pgl.Scene() scene.add(sides_shape) scene.add(bottom_shape) return scene
def test_scene(): ds = pgl.Sphere() t = pgl.Tapered(1., 1., ds) t2 = pgl.Translated(0., 0., 1., ds) sc = pgl.Scene([ pgl.Shape(t, pgl.Material((255, 0, 0))), pgl.Shape(t2, pgl.Material((0, 255, 0))) ]) jsonconversion(sc)
def pgl_scene(g, flip=False): geometry = g.property('geometry') scene = pgl.Scene() for id in geometry: if not flip: sh = pgl.Shape(geometry[id]) else: sh = pgl.Shape(pgl.AxisRotated(pgl.Vector3(1, 0, 0), pi, geometry[id])) sh.id = id scene.add(sh) return scene
def dart_display(self, radius=0.1, coef=0.8, add=False): import openalea.plantgl.all as pgl sphere = pgl.Sphere(radius,slices=16,stacks=16) coal = pgl.Material(ambient=(8,10,13),diffuse=3.,specular=(89,89,89),shininess=0.3) purple = pgl.Material(ambient=(72,28,72),diffuse=2.,specular=(89,89,89),shininess=0.3) green = pgl.Material(ambient=(0,88,9),diffuse=2.,specular=(89,89,89),shininess=0.3) blue = pgl.Material(ambient=(9,0,88),diffuse=2.,specular=(89,89,89),shininess=0.3) font = pgl.Font(size=10) s = pgl.Scene() dart_points = {} for dart in self.darts(): dart_point = self.get_position(dart) dart_face_center = self.element_center(dart,2) dart_edge_center = self.element_center(dart,1) dart_face_point = dart_face_center + coef*(dart_point-dart_face_center) dart_face_edge_center = dart_face_center + coef*(dart_edge_center-dart_face_center) dart_edge_point = dart_face_edge_center + coef*(dart_face_point-dart_face_edge_center) dart_middle_edge_point = dart_face_edge_center + 0.33*(dart_edge_point-dart_face_edge_center) dart_points[dart] = [dart_edge_point,dart_middle_edge_point] s += pgl.Shape(pgl.Translated(dart_points[dart][0],sphere),coal) # s += pgl.Shape(pgl.Translated(np.mean(dart_points[dart],axis=0), pgl.Text(str(dart),fontstyle=font)), coal, id=dart) s += pgl.Shape(pgl.Polyline(dart_points[dart],width=2),coal) for dart in self.darts(): alpha_0_points = [] alpha_0_points += [dart_points[dart][1]] alpha_0_points += [dart_points[self.alpha(0,dart)][1]] s += pgl.Shape(pgl.Polyline(alpha_0_points,width=5),purple) alpha_1_points = [] alpha_1_points += [0.66*dart_points[dart][0] + 0.33*dart_points[dart][1]] alpha_1_points += [0.66*dart_points[self.alpha(1,dart)][0] + 0.33*dart_points[self.alpha(1,dart)][1]] s += pgl.Shape(pgl.Polyline(alpha_1_points,width=5),green) alpha_2_points = [] alpha_2_points += [0.33*dart_points[dart][0] + 0.66*dart_points[dart][1]] alpha_2_points += [0.33*dart_points[self.alpha(2,dart)][0] + 0.66*dart_points[self.alpha(2,dart)][1]] s += pgl.Shape(pgl.Polyline(alpha_2_points,width=5),blue) if add : pgl.Viewer.add(s) else : pgl.Viewer.display(s)
def representation(self): mat = pgl.Material('mblue',(0,0,200),transparency=0.8) mat2 = pgl.Material('mred',(200,0,0),transparency=0.8) if not self.maxvalue: self.maxvalue = max(self.values) if self.maxvalue <= 0: return pgl.Scene() sc = pgl.Scene() for i, v in enumerate(self.values): size = v/(2*self.maxvalue) if size > 1e-2: sc += pgl.Shape(pgl.Translated(self.getVoxelCenterFromId(i),pgl.Box(self.getVoxelSize()*size)),mat,i) else: sc += pgl.Shape(pgl.Translated(self.getVoxelCenterFromId(i),pgl.Box(self.getVoxelSize()*0.1)),mat2,i) return sc
def mangoLeaf(length = 1, alpha=0, color = __niceGreen): x = array(arange(0.1,length,0.1)) y = (-3/(length*5.)) * (x**2/length - x) cos = math.cos(math.radians(alpha/2.0)) sin = math.sin(math.radians(alpha/2.0)) list = [] idxList = [] for i in range(len(x)): list.append(pgl.Vector3(x[i],0,0)) list.append(pgl.Vector3(x[i],y[i]*cos,y[i]*sin)) list.append(pgl.Vector3(x[i],-y[i]*cos,y[i]*sin)) list.append(pgl.Vector3(0,0,0)) list.append(pgl.Vector3(length,0,0)) for i in range(len(x) -1): idxList.append(pgl.Index(3*(i+1), 3*(i+1)+1, 3*i+1, 3*i )) idxList.append(pgl.Index(3*i+2, 3*(i+1)+2, 3*(i+1), 3*i )) #idxList.append(pgl.Index(3*i,3*i+1,3*(i+1)+1, 3*(i+1))) #idxList.append(pgl.Index(3*i,3*(i+1),3*(i+1)+2,3*i+2)) idxList.append(pgl.Index(0, 1, len(list)-2 )) idxList.append(pgl.Index(2, 0, len(list)-2 )) idxList.append(pgl.Index(3*(len(x)-1)+1, 3*(len(x)-1), len(list)-1 )) idxList.append(pgl.Index(3*(len(x)-1), 3*(len(x)-1)+2, len(list)-1 )) #idxList.append(pgl.Index(len(list)-2, 1, 0)) #idxList.append(pgl.Index(len(list)-2, 0, 2)) #idxList.append(pgl.Index(len(list)-1, 3*(len(x)-1), 3*(len(x)-1)+1)) #idxList.append(pgl.Index(len(list)-1, 3*(len(x)-1)+2, 3*(len(x)-1))) #p3r = pgl.Point3Array(list) #ir = pgl.IndexArray(idxList) fs = pgl.FaceSet(list,idxList) return pgl.Shape(fs, color)
def frame(matrix, scene, color=1): """ Add a frame to the scene. The frame is represented by the matrix. :param color: allow to distinguish between to identical frames. """ if color == 1: r = pgl.Material(pgl.Color3(*(255, 0, 0))) g = pgl.Material(pgl.Color3(*(0, 255, 0))) b = pgl.Material(pgl.Color3(*(0, 0, 255))) else: r = pgl.Material(pgl.Color3(*(255, 0, 255))) g = pgl.Material(pgl.Color3(*(255, 255, 0))) b = pgl.Material(pgl.Color3(*(0, 0, 0))) cylinder = pgl.Cylinder(radius=0.005, height=1) #x = pgl.AxisRotated(Vector3(0,1,0), radians(90), cylinder) #y = pgl.AxisRotated(Vector3(1,0,0), radians(-90), cylinder) z = cylinder #geom_x = transform4(matrix, x) #scene.add(pgl.Shape(geom_x, r)) #geom_y = transform4(matrix, y) #scene.add(pgl.Shape(geom_y, g)) geom_z = transform4(matrix, z) scene.add(pgl.Shape(geom_z, b))
def centroid(vid): if is_iterable(geometries[vid]): bbc.process(pgl.Scene(geometries[vid])) else: bbc.process(pgl.Scene([pgl.Shape(geometries[vid])])) center = bbc.result.getCenter() centroids[vid] = center
def leaf(**kwds): global __myLeaf if __myLeaf is None: __myLeaf = mangoLeaf(alpha=20) rp = rdm_pos((1, 1, 1)) rx, ry, rz = rp.x, rp.y, rp.z az, el, rl = rdm_orientation() x = kwds.get('x', rx) y = kwds.get('y', ry) z = kwds.get('z', rz) delta = kwds.get('rotz', az) phi = kwds.get('roty', el) psi = kwds.get('rotx', rl) size = kwds.get('len', 10.0) color = kwds.get('color', __niceGreen) if not size: size = 10.0 print "length is None, using 10 instead : small leaf" v = pgl.Vector3(x, y, z) #print "leaf size : ", size #sx = pgl.Vector3(4,1,1) * size/40. #scaled_geometry = pgl.Scaled(sx, pgl.Translated(pgl.Vector3(0.5,0,0), pgl.Disc(0.5, 6)) ) sx = pgl.Vector3(1, 1, 1) * size / 10. scaled_geometry = pgl.Scaled(sx, __myLeaf.geometry) rotated_geometry = pgl.EulerRotated(delta, phi, psi, scaled_geometry) tr = pgl.Translated(v, rotated_geometry) return pgl.Shape(tr, color)
def genericLeaf(allo_length, allo_surf, **kwds): if kwds.has_key('surface'): surface = kwds['surface'] length = math.sqrt(surface / (allo_length*allo_surf) ) else: length = kwds.get('length', 1) alpha = kwds.get('alpha', 0) color = kwds.get('color', __niceGreen) step = length/10. x = array(arange(step,length,step)) #begin and end are specific y = (-3.0*allo_length*allo_surf) * (x**2/length - x) cos = math.cos(math.radians(alpha/2.0)) sin = math.sin(math.radians(alpha/2.0)) list = [] idxList = [] for i in range(len(x)): list.append(pgl.Vector3(x[i],0,0)) list.append(pgl.Vector3(x[i],y[i]*cos,y[i]*sin)) list.append(pgl.Vector3(x[i],-y[i]*cos,y[i]*sin)) list.append(pgl.Vector3(0,0,0)) list.append(pgl.Vector3(length,0,0)) for i in range(len(x) -1): idxList.append(pgl.Index(3*(i+1), 3*(i+1)+1, 3*i+1, 3*i )) idxList.append(pgl.Index(3*i+2, 3*(i+1)+2, 3*(i+1), 3*i )) idxList.append(pgl.Index(0, 1, len(list)-2 )) idxList.append(pgl.Index(2, 0, len(list)-2 )) idxList.append(pgl.Index(3*(len(x)-1)+1, 3*(len(x)-1), len(list)-1 )) idxList.append(pgl.Index(3*(len(x)-1), 3*(len(x)-1)+2, len(list)-1 )) p3r = pgl.Point3Array(list) ir = pgl.IndexArray(idxList) fs = pgl.FaceSet(p3r, ir) return pgl.Shape(fs, color)
def mesh2shapes(scene): """ Convert all the meshes containing colors into independent shapes. """ if isinstance(scene, pgl.Scene): scene = scene else: # Case caribu scene scene = scene.scene new_scene = pgl.Scene() for shape in scene: g = shape.geometry if isinstance(g, pgl.TriangleSet) and len(g.colorList) > 0: # convert the mesh into shapes with different colors pts = g.pointList indx = g.indexList colors = g.colorList for i, ind in enumerate(indx): new_geom = pgl.TriangleSet([], []) new_geom.indexList.append(pgl.Index3(0, 1, 2)) for k in ind: new_geom.pointList.append(pts[k]) _shape = pgl.Shape(new_geom, pgl.Material(pgl.Color3(colors[i]))) new_scene.add(_shape) else: new_scene.add(shape) return new_scene,
def cvxHull(shape_list_or_scene, color=Green): """create a convex hull enveloppe :param Scene scene: a scene with shapes to process :param color color: a PGL Material to place on the convex hull :return: a PGL shape :: scene = Scene() scene += shapes hull = cvxhull(scene, color=Material(0,255,0)) scene += hull Viewer.display(hull) .. figure:: convex.png :width: 50% Example of convex hull enveloppe (of the leaves) added on top of a tree generated with pruning.lpy """ group = pgl.Group([sh.geometry for sh in shape_list_or_scene]) tglSet = pgl.fit('convexhull', group) hull = pgl.Shape(tglSet, color) return hull
def disc( x,y,z, color=color( 30,10,140 ) ): v = pgl.Vector3( x, y, z ) d = pgl.Disc( 0.4, 5 ) azimuth, elevation, roll= rdm_orientation() rotated_geometry= pgl.EulerRotated(azimuth, elevation, roll, d) tr = pgl.Translated( v,rotated_geometry ) return pgl.Shape( tr, color )
def get_source_leaf_and_max_height(g, position='center', relative_height=2. / 3): tesselator = pgl.Tesselator() bbc = pgl.BBoxComputer(tesselator) leaves = get_leaves(g, label='LeafElement') centroids = g.property('centroid') geometries = g.property('geometry') targets = list(leaf for leaf in leaves if leaf in geometries.iterkeys()) for vid in targets: if is_iterable(geometries[vid]): bbc.process(pgl.Scene(geometries[vid])) else: bbc.process(pgl.Scene([pgl.Shape(geometries[vid])])) center = bbc.result.getCenter() centroids[vid] = center zmax = max(centroids.items(), key=lambda x: x[1][2])[1][2] distances = { vid: pgl.norm(centroids[vid] - (0, 0, relative_height * zmax)) for vid in centroids } if position == 'center': return min(distances.items(), key=lambda x: x[1])[0], zmax elif position == 'border': return max(distances.items(), key=lambda x: x[1])[0], zmax
def oneScHullScene(scgroup,pointsbyshape):#aka hullscene """cree les cvxHull des groupes de scgroup""" sc = pgl.Scene() m = color(20,150,20, trans=True) for ids in scgroup: pts = ptUnion(pointsbyshape,ids) sc += pgl.Shape(pgl.fit('convexhull',pgl.Polyline(pts)),m) return sc
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 = pgl.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 = pgl.Shape(pgl.TriangleSet(pointList, indexList), appearance=pgl.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 = pgl.Shape(geometry=pgl.Polyline(pts), appearance=pgl.Material((125, 12, 12))) scene.add(crv) for pt in pts: scene.add( pgl.Shape( pgl.Translated(pgl.Vector3(pt), pgl.Sphere(radius=0.1)))) for i in range(m): pts = [ctrl_net[j][i] for j in range(n)] crv = pgl.Shape(geometry=pgl.Polyline(pts), appearance=pgl.Material((12, 12, 125))) scene.add(crv) pgl.Viewer.display(scene)
def plotSkyTurtle(): pgl.Viewer.start() sc = pgl.Scene() for i in range(len(elevations)): pos = pgl.Vector3(pgl.Vector3.Spherical(30,radians(azimuths[i]),radians(90-elevations[i]))) sc += pgl.Shape(pgl.Translated(pos,pgl.Sphere(0.5)),pgl.Material(),i+1) pgl.Viewer.display(sc) return sc
def display_leaves(g): green = pgl.Material(pgl.Color3(0, 150, 0)) scene = pgl.Scene() for vid, geom in g.property('geometry').items(): sh = pgl.Shape(geom, green) sh.id = vid scene.add(sh) pgl.Viewer.display(scene) return scene
def get_leaf_height(self, leaf_geom): from openalea.plantgl import all as pgl tesselator = pgl.Tesselator() bbc = pgl.BBoxComputer(tesselator) if self.is_iterable(leaf_geom): bbc.process(pgl.Scene(leaf_geom)) else: bbc.process(pgl.Scene([pgl.Shape(leaf_geom)])) return bbc.result.getCenter()[2]
def _local2global(self, vid, matrix, color): g = self._graph geometry = g.vertex_property("geometry") colors = g.vertex_property("color") final_geometry = g.vertex_property("final_geometry") shape = geometry.get(vid) edge_type = g.edge_property("edge_type") if shape: if color: shape = pgl.Shape(transform4(matrix, shape), pgl.Material(color)) else: shape = pgl.Shape(transform4(matrix, shape)) shape.id = vid final_geometry[vid] = shape if color: colors[vid] = color
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 """ 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)))
def simple_tree(height=2, crown_radius=1, n_leaves=500, leaf_area=0.1, inner=True): """return a simple tree scene""" leaves = random_leaves(n_leaves=n_leaves, leaf_area=leaf_area, crown_radius=crown_radius, crown_center=(0, 0, height), inner=inner) trunk = pgl.Cylinder(0.1, height) green = pgl.Material(pgl.Color3(0, 150, 0)) brown = pgl.Material(pgl.Color3(100, 60, 10)) scene = pgl.Scene() scene.add(pgl.Shape(trunk, brown)) for leaf in leaves: scene.add(pgl.Shape(leaf, green)) return scene
def plot_spline_crv(ctrls, pts): """ Parameters ========== - ctrl: control points - pts : evaluated points on the curve """ scene = pgl.Scene() crvContols = pgl.Shape(geometry=pgl.Polyline(ctrls), appearance=pgl.Material((12, 125, 12))) scene.add(crvContols) crv = pgl.Shape(geometry=pgl.Polyline(pts), appearance=pgl.Material((125, 12, 12))) scene.add(crv) # To complete: Draw the control points and the line between each ones. pgl.Viewer.display(scene)
def mesh_display(points, triangles, color=[190,205,205], transparency=0, add=False): import openalea.plantgl.all as pgl if color is None: color = [np.random.randint(0,255) for i in xrange(3)] mat = pgl.Material(tuple(color), diffuse=0.25, transparency=transparency) s = pgl.Scene() s += pgl.Shape(pgl.FaceSet(points, triangles), mat) if add : pgl.Viewer.add(s) else : pgl.Viewer.display(s)
def arrow(x,y,z,length,az=0, el=0, radius=None, color=color(255,255,255),id=0): if radius==None: radius=length*0.05 rad_az = math.radians(az) rad_el = math.pi/2 - math.radians(el) v = pgl.Vector3( x, y, z ) c = pgl.Cylinder(radius, length*0.8, 10) con =pgl.Translated(pgl.Vector3(0,0,length*0.7), pgl.Cone(2*radius, length*0.3)) arr = pgl.Group([c,con]) dir_arr = pgl.EulerRotated(rad_az,rad_el,0,arr) tr_dir_arr = pgl.Translated(v,dir_arr) return pgl.Shape(tr_dir_arr, color, id)