def setup_func():
sc = pgl.Scene()
sc += pgl.Shape(pgl.Box(1, 1, 1), red, id=1)
sc += pgl.Shape(pgl.Translated(4, 4, 6, pgl.Sphere(1)), blue, id=2)
sc += pgl.Shape(pgl.Translated(2, 3, -3, pgl.Cone(1, 2)), green, id=3)
sc += pgl.Shape(pgl.Translated(-8, 3, -2, pgl.Box(4, 2, 0.5)), blue, id=4)
sc += pgl.Shape(pgl.Translated(
-4, -2, 5, pgl.EulerRotated(3.14, 2.7, 0, pgl.Cone(2, 5))),
green,
id=5)
sc += pgl.Shape(pgl.Translated(4, -3, -3, pgl.Sphere(2)), red, id=6)
return sc
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 inflorescence(g, vid, turtle):
"""Generates the inflorescences
HT: inflorescence
Box (may change)
for each HT in mtg return an object compose of cylender and a blue box.
Shape of the box is dependent of the number of total flower and number of open flowers.
:param g: MTG
:type g: MTG
:param vid: vid selected
:type vid: int
:param turtle: Turtle
:type turtle: Turtle
:return: for each HT in mtg return an object compose of cylender and a blue box.
:rtype: [type]
"""
t = colors_turtle(turtle)
nid = g.node(vid)
order = nid.order
nb_flower = nid.FLWRNUMBER
nb_flower_open = nid.FLWRNUMBER_OPEN
t.setColor(2+order)
turtle.F(0.2)
if nb_flower is None:
nb_flower = 0.5
if nb_flower_open is None or nb_flower_open == 0:
nb_flower_open = 0.5
cube = pgl.Box(0.05*pgl.Vector3(1,1,nb_flower_open/4.))
tap = pgl.Tapered(3./20*nb_flower, 3./20*nb_flower_open, cube)
turtle.customGeometry(tap)
def toPglScene( self, geometry=None ):
"""
Generate a PlantGL scene of the MST with the given geometry which size
must be normalized ( < 1), default is a box
"""
if self.dim < 4:
scene = pgl.Scene()
if geometry == None:
geometry = pgl.Box(0.4)
( ptList, size ) = self.absolutePos()
#x = y = z = 0
for pt in ptList :
try:
x = pt[ 0 ]
except IndexError:
x = 0
try:
y = pt[ 1 ]
except IndexError:
y = 0
try:
z = pt[ 2 ]
except IndexError:
z = 0
scene.add( pgl.Translated( (x, y, z), geometry ))
else:
print "Bad dimension"
return scene
def inflorescence(g, vid, turtle):
""" HT: inflorescence
Box (may change)
parameters:
-----------
g: is a current MTG
vid: vertex id in the mtg
turtle: openalea.pltgl.turtle
return:
----------
for each HT in mtg return an object compose of cylender and a blue box.
Shape of the box is dependent of the number of total flower and number of open flowers.
"""
t = colors_turtle(turtle)
nid = g.node(vid)
order = nid.order
nb_flower = nid.FLWRNUMBER
nb_flower_open = nid.FLWRNUMBER_OPEN
t.setColor(2 + order)
turtle.F(0.2)
if nb_flower is None:
nb_flower = 0.5
if nb_flower_open is None or nb_flower_open == 0:
nb_flower_open = 0.5
cube = pgl.Box(0.05 * pgl.Vector3(1, 1, nb_flower_open / 4.))
tap = pgl.Tapered(3. / 20 * nb_flower, 3. / 20 * nb_flower_open, cube)
turtle.customGeometry(tap)
def Inflo_Primordia(g, vid, turtle):
""" ht: Primordia inflorescence
"""
t = turtle
#turtle.setColor(1)
nid = g.node(vid)
order = nid.order
t.setColor(8 + order)
turtle.F(0.1)
cube = pgl.Box(0.02 * pgl.Vector3(1, 1, 1))
turtle.customGeometry(cube)
def inflorescence2d(g, v, turtle):
len_internode=0.2
turtle.F(len_internode)
box = pgl.Box(0.05*pgl.Vector3(1,1,2))
# box_axis = pgl.AxisRotated(axis=(0,1,0), angle =45.,geometry=box)
# box2 = pgl.Translated(.5,0,.8,box_axis)
# cyl = pgl.Cylinder(.01,0.5)
# cyl2 = pgl.AxisRotated(axis=(0,1,0), angle= 45., geometry= cyl)
# cyl3 = pgl.Translated(0,0,0.5,cyl2)
# shape= pgl.Group([cyl,cyl3,box2])
turtle.customGeometry(box)
def inflo_primordia(g, vid, turtle):
""" ht: Primordia inflorescence
parameters:
-----------
g: is a current MTG
vid: vertex id in the mtg
turtle: openalea.pltgl.turtle
return:
-------
for each ht in mtg return an object compose of a cylinder and a of orange cube
"""
t = colors_turtle(turtle)
nid = g.node(vid)
order = nid.order
t.setColor(8 + order)
turtle.F(0.1)
cube = pgl.Box(0.02 * pgl.Vector3(1, 1, 1))
turtle.customGeometry(cube)
def Inflorescence(g, vid, turtle):
""" HT: Inflorescence
Box (may change)
"""
t = turtle
nid = g.node(vid)
order = nid.order
#turtle.setColor(3)
nb_flower = nid.Fleurs_total
nb_flower_open = nid.Fleurs_ouverte
t.setColor(2 + order)
turtle.F(0.2)
if nb_flower is None:
nb_flower = 0.5
if nb_flower_open is None or nb_flower_open == 0:
nb_flower_open = 0.5
cube = pgl.Box(0.05 * pgl.Vector3(1, 1, nb_flower_open / 4.))
tap = pgl.Tapered(3. / 20 * nb_flower, 3. / 20 * nb_flower_open, cube)
turtle.customGeometry(tap)
def inflo_primordia2d(g, vid, turtle):
"""Generates inflorescence primordia
ht: Primordia inflorescence
:param g: MTG
:type g: MTG
:param vid: vid selected
:type vid: int
:param turtle: Turtle
:type turtle: Turtle
:return: for each ht in mtg return an object compose of a cylinder and a of orange cube
:rtype: [type]
"""
# len_internode=0.25
t = colors_turtle(turtle)
nid = g.node(vid)
order = nid.order
t.setColor(8+order)
# turtle.F(len_internode)
cube = pgl.Box(0.03*pgl.Vector3(1,1,1))
turtle.customGeometry(cube)
def pgl_representation(self,
cm='jet',
property_name='QWater',
sizeratio=0.1,
transparency=0,
minvalue=None,
maxvalue=None,
scalefunc=None,
cmview=False,
scaling=1):
""" return Plantgl scene """
if property_name not in self.property_names(): return
mproperty = self.property(property_name)
if (not scalefunc is None) and ((not minvalue is None) or
(not maxvalue is None)):
vscalefunc = np.vectorize(scalefunc)
mproperty = vscalefunc(mproperty)
minvalue = mproperty.min() if minvalue is None else minvalue
maxvalue = mproperty.max() if maxvalue is None else maxvalue
colormap = pgl.PglMaterialMap(minvalue, maxvalue, cm)
sc = pgl.Scene()
vsize = np.array(self.dxyz) * sizeratio / 2.
it = np.nditer(self.property(property_name), flags=['multi_index'])
while not it.finished:
idx, value = it.multi_index, it[0]
if not scalefunc is None: value = scalefunc(value)
if minvalue <= value <= maxvalue:
mat = colormap(value)
mat.transparency = transparency
sc += pgl.Shape(
pgl.Translated(
self.getVoxelCenter(idx) * scaling,
pgl.Box(vsize * scaling)), mat)
it.iternext()
if cmview:
sc += colormap.pglrepr()
return sc
def box( x, y, z, radius=0.45, color=color( 80, 200, 100 ), id=None ): v = pgl.Vector3( x, y, z ) b = pgl.Box( pgl.Vector3( radius, radius, radius ) ) tr = pgl.Translated( v, b ) return pgl.Shape( tr, color,id )
def Box(self, depth=1., width=1., height=1., **kwds):
depth, width, height = float(depth), float(width), float(height)
size = Vector3(depth / 2, width / 2, height / 2)
return (pgl.Translated((0, 0, height / 2), pgl.Box(size)),
pgl.Matrix4.translation(Vector3(0, 0, height)))
def voxelize(scene, gridSize, density=True):
"""
Generate the scene resulting of grid discretization
:Parameters:
- `Scene` : PlantGL scene
- `Division Factor` : Division factor of the bounding box
- `Density` : Taking density into account
:Types:
- `Scene` : Pgl scene
- `Division Factor` : int
- `Density` : boolean
:returns:
- `Voxel size` : List of intercepted voxels size
- `Centers` : List of intercepted voxels centers
- `Densities` : List of intercepted voxels densities
- `VoxScene` : Scene of intercepted voxels
:returntype:
- `Voxel size` : [ float ]
- `Centers` : [ ( float ) ]
- `Densities` : [ float ]
- `VoxScene` : Plg scene
"""
#scene = pgl.Scene(sceneFile)
bbox = pgl.BoundingBox(scene)
epsilon = pgl.Vector3(0.01, 0.01, 0.01)
origin = bbox.lowerLeftCorner - epsilon
step = (bbox.getSize() + epsilon) * 2 / (gridSize)
origin_center = origin + step / 2.
tgl_list = surfPerTriangle(scene)
grid = {}
for tgl in tgl_list:
pos = gridIndex(tgl[0] - origin, step)
assert (pos[0] < gridSize and pos[1] < gridSize and pos[2] < gridSize)
if grid.has_key(pos):
grid[pos] += tgl[1]
else:
grid[pos] = tgl[1]
kize = grid.keys()
kize.sort()
pts = []
mass = []
for k in kize:
pts.append(list(k))
mass.append(grid[k])
massort = deepcopy(mass)
massort.sort()
qlist = [25, 50, 75]
quants = [massort[int(len(massort) * q / 100.0)] for q in qlist]
voxSize = step / 2.
vox = pgl.Box(voxSize)
vox.setName('voxel')
mat1 = color(47, 255, 0, trans=True, name='c_green')
mat2 = color(255, 255, 0, trans=True, name='c_yellow')
mat3 = color(255, 170, 0, trans=True, name='c_orange')
mat4 = color(255, 0, 0, trans=True, name='c_red')
#sc = pgl.Scene()
ctrs = []
for i in xrange(len(pts)):
pt = pts[i]
vect = pgl.Vector3(origin_center.x + (pt[0] * step.x),
origin_center.y + (pt[1] * step.y),
origin_center.z + (pt[2] * step.z))
ctrs.append(vect)
geometry = pgl.Translated(vect, vox)
if (density):
if (mass[i] < quants[0]):
sh = pgl.Shape(geometry, mat1, i)
elif (mass[i] < quants[1]):
sh = pgl.Shape(geometry, mat2, i)
elif (mass[i] < quants[2]):
sh = pgl.Shape(geometry, mat3, i)
else:
sh = pgl.Shape(geometry, mat4, i)
else:
sh = pgl.Shape(geometry, mat1, i)
scene.add(sh)
vxls = Voxels(voxSize, ctrs, mass)
#return (vxls, scene)
return (voxSize, ctrs, mass, scene)
import openalea.fractalysis.engine as eng
import openalea.plantgl.all as pgl
vec = [(1, 1, 1), (1, 1, -1), (1, -1, 1), (1, -1, -1), (-1, 1, 1), (-1, 1, -1),
(-1, -1, 1), (-1, -1, -1)]
box = pgl.Box((0.45, 0.45, 0.45))
cantor_dust = pgl.Scene()
for v in vec:
cantor_dust.add(pgl.Shape(pgl.Translated(v, box)))
def test_computeGrid():
res = eng.computeGrid(cantor_dust, 3)
assert res[
0] == 8, 'Intercepted voxels number should be 8 but is %d' % res[0]
def test_computeGrids():
res = eng.computeGrids(cantor_dust, 5)
assert res[0][
0] == 8, 'Intercepted voxels number should be 8 but is %d' % res[0][0]
assert res[-1][
0] == 64, 'Intercepted voxels number should be 64 but is %d' % res[-1][
0]
def test_MatrixLac_generation():
pts = [[0, 0, 0], [0, 0, 1], [0, 0, 3], [0, 0, 4], [0, 1, 0], [0, 1, 1],
[0, 1, 3], [0, 1, 4], [0, 3, 0], [0, 3, 1], [0, 3, 3], [0, 3, 4],
[0, 4, 0], [0, 4, 1], [0, 4, 3], [0, 4, 4], [1, 0, 0], [1, 0, 1],
