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 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 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 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 sweep(vid):
_color = pgl.Material(color(vid))
if diams and (vid in diams):
diameters = diams[vid]
if isinstance(diameters, (list, tuple)):
_geom = pgl.Extrusion(
pgl.Polyline(map(pgl.Vector3, geoms[vid])), section,
pgl.Point2Array(zip(diams[vid], diams[vid])))
else:
_geom = pgl.Extrusion(
pgl.Polyline(map(pgl.Vector3, geoms[vid])), section,
pgl.Point2Array([(diameters, diameters)
for i in range(len(geoms))]))
else:
_geom = pgl.Extrusion(pgl.Polyline(map(pgl.Vector3, geoms[vid])),
section)
return pgl.Shape(_geom, _color)
def normal(set):
pts = set.pointList
indices = set.indexList
geoms = []
for index in indices:
i1, i2, i3 = index
p1, p2, p3 = pts[i1], pts[i2], pts[i3]
pt_bary = (p1 + p2 + p3) / 3.
n = (p2 - p1) ^ (p3 - p1)
geoms.append(pgl.TriangleSet([p1, p2, p3], [(0, 1, 2)]))
geoms.append(pgl.Polyline([pt_bary, pt_bary + n]))
return geoms
def skeleton(scene, threshold=0.01):
result = []
for shape in scene:
position = pgl.Vector3(0, 0, 0)
heading = pgl.Vector3(0, 0, 1)
geometry = shape.geometry
while isinstance(geometry, pgl.Transformed):
if isinstance(geometry, pgl.Translated):
position = geometry.translation
if isinstance(geometry, pgl.Oriented):
heading = cross(geometry.primary, geometry.secondary)
geometry = geometry.geometry
if isinstance(geometry, pgl.Cylinder) or isinstance(
geometry, pgl.Cone):
line = pgl.Polyline(
[position, position + heading * geometry.height])
splits = max(1, line.getLength() / threshold)
for i in linspace(0, 1, splits):
subline = line.split(i)[0]
result.append(subline.pointList[1])
elif isinstance(geometry, pgl.Extrusion):
result.append(geometry.axis)
result = pgl.PointSet(result)
return result
def ptsHull( ptsList, id = 0 ):
m = color( 20,150,20,trans=True )
shape = pgl.Shape(pgl.fit('convexhull',pgl.Polyline(ptsList)),m)
shape.id = id
return shape
