def draw_labels(labels, **kwargs):
"""Draw labels as text dots and optionally set individual font, fontsize, name and color.
Parameters
----------
labels : list of dict
A list of labels dictionaries.
Returns
-------
list of GUID
Notes
-----
A label dict has the following schema:
.. code-block:: python
Schema({
'pos': And(list, lambda x: len(x) == 3),
'text': And(str, len),
Optional('name', default=''): str,
Optional('color', default=None): (lambda x: len(x) == 3 and all(0 <= y <= 255 for y in x)),
Optional('fontsize', default=10): Or(int, float),
Optional('font', default="Arial Regular"): str
})
"""
guids = []
for label in iter(labels):
pos = label['pos']
text = label['text']
name = label.get('name', '')
color = label.get('color', None)
size = label.get('fontsize', 10)
font = label.get('font', 'Arial Regular')
dot = TextDot(str(text), Point3d(*pos))
dot.FontHeight = size
dot.FontFace = font
guid = add_dot(dot)
if not guid:
continue
obj = find_object(guid)
if not obj:
continue
attr = obj.Attributes
if color:
attr.ObjectColor = FromArgb(*color)
attr.ColorSource = ColorFromObject
else:
attr.ColorSource = ColorFromLayer
attr.Name = name
obj.CommitChanges()
guids.append(guid)
return guids
def OnDynamicDraw(sender, e):
cp = e.CurrentPoint
translation = cp - ip
for vertex in vertices:
xyz = diagram.vertex_coordinates(vertex)
sp = Point3d(*xyz)
for nbr_vkey in nbr_vkeys[vertex]:
nbr = diagram.vertex_coordinates(nbr_vkey)
np = Point3d(*nbr)
line = Rhino.Geometry.Line(sp, sp + translation)
e.Display.DrawDottedLine(np, sp + translation, dotted_color)
e.Display.DrawArrow(line, arrow_color, 15, 0)
for pair in list(edges):
pair = list(pair)
u = diagram.vertex_coordinates(pair[0])
v = diagram.vertex_coordinates(pair[1])
sp = Point3d(*u) + translation
ep = Point3d(*v) + translation
e.Display.DrawLine(sp, ep, edge_color, 3)
def OnDynamicDraw(sender, e):
cp = e.CurrentPoint
for vertex in vertices:
xyz = diagram.vertex_coordinates(vertex)
sp = Point3d(*xyz)
sp_f = update_point(sp, cp)
for nbr_vkey in nbr_vkeys[vertex]:
nbr = diagram.vertex_coordinates(nbr_vkey)
np = Point3d(*nbr)
e.Display.DrawDottedLine(np, sp_f, dotted_color)
e.Display.DrawLine(sp, sp_f, edge_color, 3)
for pair in list(edges):
pair = list(pair)
u = diagram.vertex_coordinates(pair[0])
v = diagram.vertex_coordinates(pair[1])
sp = update_point(Point3d(*u), cp)
ep = update_point(Point3d(*v), cp)
e.Display.DrawLine(sp, ep, edge_color, 3)
def _face_adjacency(xyz, faces, nmax=10, radius=2.0):
points = [
centroid_points([xyz[index] for index in face]) for face in faces
]
tree = RTree()
for i, point in enumerate(points):
tree.Insert(Point3d(*point), i)
def callback(sender, e):
data = e.Tag
data.append(e.Id)
closest = []
for i, point in enumerate(points):
sphere = Sphere(Point3d(*point), radius)
data = []
tree.Search(sphere, callback, data)
closest.append(data)
adjacency = {}
for face, vertices in enumerate(faces):
nbrs = []
found = set()
nnbrs = set(closest[face])
for u, v in pairwise(vertices + vertices[0:1]):
for nbr in nnbrs:
if nbr == face:
continue
if nbr in found:
continue
for a, b in pairwise(faces[nbr] + faces[nbr][0:1]):
if v == a and u == b:
nbrs.append(nbr)
found.add(nbr)
break
for a, b in pairwise(faces[nbr] + faces[nbr][0:1]):
if u == a and v == b:
nbrs.append(nbr)
found.add(nbr)
break
adjacency[face] = nbrs
return adjacency
def xdraw_breps(faces, srf=None, u=10, v=10, trim=True, tangency=True, spacing=0.1, flex=1.0, pull=1.0):
"""Draw polygonal faces as Breps, and optionally set individual name, color,
and layer properties.
"""
guids = []
for f in iter(faces):
points = f['points']
name = f.get('name', '')
color = f.get('color')
layer = f.get('layer')
corners = [Point3d(*point) for point in points]
pcurve = PolylineCurve(corners)
geo = List[GeometryBase](1)
geo.Add(pcurve)
p = len(points)
if p == 4:
brep = Brep.CreateFromCornerPoints(Point3d(*points[0]),
Point3d(*points[1]),
Point3d(*points[2]),
TOL)
elif p == 5:
brep = Brep.CreateFromCornerPoints(Point3d(*points[0]),
Point3d(*points[1]),
Point3d(*points[2]),
Point3d(*points[3]),
TOL)
else:
brep = Brep.CreatePatch(geo, u, v, TOL)
if not brep:
continue
guid = add_brep(brep)
if not guid:
continue
obj = find_object(guid)
if not obj:
continue
attr = obj.Attributes
if color:
attr.ObjectColor = FromArgb(*color)
attr.ColorSource = ColorFromObject
else:
attr.ColorSource = ColorFromLayer
if layer:
index = find_layer_by_fullpath(layer, True)
if index >= 0:
attr.LayerIndex = index
attr.Name = name
attr.WireDensity = -1
obj.CommitChanges()
guids.append(guid)
return guids
def xdraw_cylinders(cylinders, cap=False):
rg_cylinders = []
for c in iter(cylinders):
start = c['start']
end = c['end']
radius = c['radius']
if radius < TOL:
continue
base = Point3d(*start)
normal = Point3d(*end) - base
height = normal.Length
if height < TOL:
continue
plane = Plane(base, normal)
circle = Circle(plane, radius)
cylinder = Cylinder(circle, height)
brep = cylinder.ToBrep(cap, cap)
if not brep:
continue
rg_cylinders.append(brep)
return rg_cylinders
def point_to_rhino(point):
"""Convert a COMPAS point to a Rhino point.
Parameters
----------
point : :class:`compas.geometry.Point`
Returns
-------
:class:`Rhino.Geometry.Point3d`
"""
return Point3d(point[0], point[1], point[2])
def draw_points(points, **kwargs):
"""Draw points and optionally set individual name, layer, and color properties.
Parameters
----------
labels : list[dict]
A list of point dictionaries.
See Notes, for more information about the structure of the dict.
Returns
-------
list[System.Guid]
Notes
-----
A point dict has the following schema:
.. code-block:: python
Schema({
'pos': And(list, lambda x: len(x) == 3),
Optional('name', default=''): str,
Optional('color', default=None): (lambda x: len(x) == 3 and all(0 <= y <= 255 for y in x)),
Optional('layer', default=None): str
})
"""
guids = []
for p in iter(points):
pos = p['pos']
name = p.get('name', '')
color = p.get('color')
layer = p.get('layer')
guid = add_point(Point3d(*pos))
if not guid:
continue
obj = find_object(guid)
if not obj:
continue
attr = obj.Attributes
if color:
attr.ObjectColor = FromArgb(*color)
attr.ColorSource = ColorFromObject
else:
attr.ColorSource = ColorFromLayer
if layer and find_layer_by_fullpath:
index = find_layer_by_fullpath(layer, True)
if index >= 0:
attr.LayerIndex = index
attr.Name = name
obj.CommitChanges()
guids.append(guid)
return guids
def xdraw_lines(lines, **kwargs):
"""Draw lines and optionally set individual name, color, arrow, layer, and
width properties.
"""
guids = []
for l in iter(lines):
sp = l['start']
ep = l['end']
name = l.get('name', '')
color = l.get('color')
arrow = l.get('arrow')
layer = l.get('layer')
width = l.get('width')
guid = add_line(Point3d(*sp), Point3d(*ep))
if not guid:
continue
obj = find_object(guid)
if not obj:
continue
attr = obj.Attributes
if color:
attr.ObjectColor = FromArgb(*color)
attr.ColorSource = ColorFromObject
else:
attr.ColorSource = ColorFromLayer
if arrow == 'end':
attr.ObjectDecoration = EndArrowhead
if arrow == 'start':
attr.ObjectDecoration = StartArrowhead
if layer and find_layer_by_fullpath:
index = find_layer_by_fullpath(layer, True)
if index >= 0:
attr.LayerIndex = index
if width:
attr.PlotWeight = width
attr.PlotWeightSource = PlotWeightFromObject
attr.Name = name
obj.CommitChanges()
guids.append(guid)
return guids
def trimesh_slice(mesh, planes):
"""Slice a mesh by a list of planes.
Parameters
----------
mesh : tuple of vertices and faces
The mesh to slice.
planes : list of (point, normal) tuples or compas.geometry.Plane
The slicing planes.
Returns
-------
list of arrays
The points defining the slice polylines.
Examples
--------
>>> from compas.geometry import Sphere, Plane, Point, Vector
>>> sphere = Sphere([1, 1, 1], 1)
>>> sphere = sphere.to_vertices_and_faces(u=30, v=30)
>>> P1 = Plane(Point(0, 0, 0), Vector(0, -1, 0))
>>> P2 = Plane(Point(0, 0, 0), Vector(0.87, -0.5, 0))
>>> planes = [P1, P2]
>>> points = trimesh_slice(sphere, planes)
"""
# (0) see if input is already Rhino.Geometry.Mesh
M = Rhino.Geometry.Mesh()
if not isinstance(mesh, Rhino.Geometry.Mesh):
for x, y, z in mesh[0]:
M.Vertices.Add(x, y, z)
for face in mesh[1]:
M.Faces.AddFace(*face)
else:
M = mesh
# (1) parse to Rhino.Geometry.Plane
P = []
for plane in planes:
point = Point3d(plane[0][0], plane[0][1], plane[0][2])
normal = Vector3d(plane[1][0], plane[1][1], plane[1][2])
P.append(Plane(point, normal))
# (2) Slice
polylines = MeshPlane(M, P)
# (3) Return points in a list of arrays
polyline_pts = []
for polyline in polylines:
pts = []
for i in range(polyline.Count):
pts.append([polyline.X[i], polyline.Y[i], polyline.Z[i]])
polyline_pts.append(pts)
return polyline_pts
def DrawForeground(self, e):
_conduit_volmesh_edges(self.volmesh, e)
if self.face_colordict:
for fkey in self.face_colordict:
color = FromArgb(*self.face_colordict[fkey])
f_vkeys = self.volmesh.halfface_vertices(fkey)
points = [
self.volmesh.vertex_coordinates(vkey) for vkey in f_vkeys
]
points.append(points[0])
points = [Point3d(*pt) for pt in points]
e.Display.DrawPolygon(points, color, filled=True)
def contourBrepInZ(brep, stepSize):
# get the upper and lower limits
bbox = brep.GetBoundingBox(True)
zMin, zMax = bbox.Min.Z, bbox.Max.Z
zRange = zMax-zMin
vect = Vector3d(0.0,0.0,1.0)
# the next line is dense
planes = [Plane(Point3d(0.0, 0.0, z), vect) for z in RangeTools.drange(zMin,zMax, 0.5)]
resultList = []
for plane in planes:
curves = brep.CreateContourCurves(brep, plane)
resultList.append(curves)
return resultList
def DrawForeground(self, e):
p1 = self.mouse.p1
p2 = self.mouse.p2
v12 = subtract_vectors(p2, p1)
l12 = length_vector(v12)
hfkeys = self.volmesh.faces()
if self.hfkeys:
hfkeys = self.hfkeys
for hfkey in hfkeys:
p0 = self.volmesh.halfface_center(hfkey)
v01 = subtract_vectors(p1, p0)
v02 = subtract_vectors(p2, p0)
l = length_vector(cross_vectors(v01, v02))
if l12 == 0.0 or (l / l12) < self.tol:
face_coordinates = self.volmesh.halfface_coordinates(hfkey)
face_coordinates.append(face_coordinates[0])
polygon_xyz = [Point3d(*xyz) for xyz in face_coordinates]
e.Display.DrawPolyline(polygon_xyz, self.edgecolor, 6)
if self.dependents:
d_hfkeys = self.volmesh.volmesh_edge_dependents_all(hfkey)
for d_hfkey in d_hfkeys:
face_coordinates = self.volmesh.halfface_coordinates(
d_hfkey)
face_coordinates.append(face_coordinates[0])
polygon_xyz = [
Point3d(*xyz) for xyz in face_coordinates
]
e.Display.DrawPolyline(polygon_xyz, self.edgecolor, 2)
break
def xdraw_geodesics(geodesics, **kwargs):
"""Draw geodesic lines on specified surfaces, and optionally set individual
name, color, arrow, and layer properties.
"""
guids = []
for g in iter(geodesics):
sp = g['start']
ep = g['end']
srf = g['srf']
name = g.get('name', '')
color = g.get('color')
arrow = g.get('arrow')
layer = g.get('layer')
# replace this by a proper rhinocommon call
guid = rs.ShortPath(srf, Point3d(*sp), Point3d(*ep))
if not guid:
continue
obj = find_object(guid)
if not obj:
continue
attr = obj.Attributes
if color:
attr.ObjectColor = FromArgb(*color)
attr.ColorSource = ColorFromObject
else:
attr.ColorSource = ColorFromLayer
if arrow == 'end':
attr.ObjectDecoration = EndArrowhead
if arrow == 'start':
attr.ObjectDecoration = StartArrowhead
if layer and find_layer_by_fullpath:
index = find_layer_by_fullpath(layer, True)
if index >= 0:
attr.LayerIndex = index
attr.Name = name
obj.CommitChanges()
guids.append(guid)
return guids
def DrawForeground(self, e):
"""Draw the points.
Parameters
----------
e : Rhino.Display.DrawEventArgs
Returns
-------
None
"""
for xyz, size, color in zip(self.points, self.size, self.color):
e.Display.DrawPoint(Point3d(*xyz), Simple, size, color)
def OnDynamicDraw(sender, e):
cp = e.CurrentPoint
plane = (cp, normal)
line = (center, add_vectors(center, normal))
it = intersection_line_plane(line, plane)
translation = subtract_vectors(it, center)
dot = dot_vectors(normal, translation)
dot = dot / abs(dot)
dist = distance_point_point(center, it) * dot
for hfkey in hfkeys:
hf_center = volmesh.halfface_center(hfkey)
hf_normal = volmesh.halfface_oriented_normal(hfkey)
ep = add_vectors(hf_center, scale_vector(hf_normal, dist))
e.Display.DrawDottedLine(Point3d(*hf_center), Point3d(*ep),
feedback_color)
e.Display.DrawPoint(Point3d(*ep), 0, 4, black)
for vkey in volmesh.halfface_vertices(hfkey):
sp = volmesh.vertex_coordinates(vkey)
e.Display.DrawLine(Point3d(*sp), Point3d(*ep), black, 2)
def DrawForeground(self, e):
draw_dot = e.Display.DrawDot
draw_arrows = e.Display.DrawArrows
a = self.mouse.p1
b = self.mouse.p2
ab = subtract_vectors(b, a)
Lab = length_vector(ab)
if not Lab:
return
for index, vertex in enumerate(self.vertex_xyz):
c = self.vertex_xyz[vertex]
D = length_vector(
cross_vectors(subtract_vectors(a, c), subtract_vectors(b, c)))
if D / Lab < self.tol:
point = Point3d(*c)
draw_dot(point, str(index), self.dotcolor, self.textcolor)
lines = List[Line](len(self.vertex_nbr[vertex]))
for u, v in self.vertex_nbr[vertex]:
lines.Add(
Line(Point3d(*self.vertex_xyz[u]),
Point3d(*self.vertex_xyz[v])))
draw_arrows(lines, self.linecolor)
break
def RunCommand():
# select a surface
srfid = rs.GetObject("select serface",
rs.filter.surface | rs.filter.polysurface)
if not srfid: return
# get the brep
brep = rs.coercebrep(srfid)
if not brep: return
x = rs.GetReal("value of x", 0)
y = rs.GetReal("value of y", 0)
pts = [(abs(point.Z), point.Z)
for point in Intersect.Intersection.ProjectPointsToBreps(
[brep], [Point3d(x, y, 0)], Vector3d(
0, 0, 1), doc.ModelAbsoluteTolerance)]
pts.sort(reverse=True)
if pts == []:
print "no Z for given X, Y"
else:
rs.AddPoint(Point3d(x, y, pts[0][1]))
def DrawForeground(self, e):
p1 = self.mouse.p1
p2 = self.mouse.p2
v12 = subtract_vectors(p2, p1)
l12 = length_vector(v12)
for index, (key, attr) in enumerate(self.mesh.vertices(True)):
p0 = attr['x'], attr['y'], attr['z']
text = str(index)
v01 = subtract_vectors(p1, p0)
v02 = subtract_vectors(p2, p0)
l = length_vector(cross_vectors(v01, v02)) # noqa: E741
if l12 == 0.0 or (l / l12) < self.tol:
point = Point3d(*p0)
e.Display.DrawDot(point, text, self.dotcolor, self.textcolor)
break
def separation(self, boids, radius=3, angle=10):
neighbors = self.get_neighbors(boids, radius, angle)
pox = 0
poy = 0
poz = 0
if len(neighbors) > 0:
n_neighbors = len(neighbors)
for i in neighbors:
pox += i.position.X
poy += i.position.Y
poz += i.position.Z
center = Point3d(pox / n_neighbors, poy / n_neighbors,
poz / n_neighbors)
return (center - self.position) * -1
else:
return Vector3d(0, 0, 0)
def xdraw_pipes(pipes, cap=2, fit=1.0):
abs_tol = TOL
ang_tol = sc.doc.ModelAngleToleranceRadians
for p in pipes:
points = p['points']
radius = p['radius']
params = [0.0, 1.0]
cap = ToObject(PipeCapMode, cap)
if type(radius) in (int, float):
radius = [radius] * 2
radius = [float(r) for r in radius]
rail = Curve.CreateControlPointCurve([Point3d(*xyz) for xyz in points])
breps = Brep.CreatePipe(rail, params, radius, 1, cap, fit, abs_tol,
ang_tol)
for brep in breps:
yield brep
def draw_labels(labels, **kwargs):
"""Draw labels as text dots and optionally set individual font, fontsize, name and color.
Parameters
----------
labels : list of dict
A list of labels dictionaries.
A label dictionary has the following structure:
.. code-block:: python
{
'pos' : [x, y, z],
'text' : '',
'name' : ''
}
"""
guids = []
for l in iter(labels):
pos = l['pos']
text = l['text']
name = l.get('name', '')
color = l.get('color', None)
size = l.get('fontsize', 10)
font = l.get('font', 'Arial Regular')
dot = TextDot(str(text), Point3d(*pos))
dot.FontHeight = size
dot.FontFace = font
guid = add_dot(dot)
if not guid:
continue
obj = find_object(guid)
if not obj:
continue
attr = obj.Attributes
if color:
attr.ObjectColor = FromArgb(*color)
attr.ColorSource = ColorFromObject
else:
attr.ColorSource = ColorFromLayer
attr.Name = name
obj.CommitChanges()
guids.append(guid)
return guids
def DrawForeground(self, e):
"""Draw the faces as polygons.
Parameters
----------
e : Rhino.Display.DrawEventArgs
Returns
-------
None
"""
for i, face in enumerate(self.faces):
points = [Point3d(*self.vertices[key]) for key in face]
if self.color:
e.Display.DrawPolygon(points, self.color[i], True)
else:
e.Display.DrawPolygon(points, self.default_color, True)
def copy(self):
if self.transformable == True:
values_copy = []
for val in self.values:
val_copy = None
if type(val) == Point3d:
val_copy = Point3d(val)
elif type(val) == Plane:
val_copy = Plane(val)
elif type(val) == Line:
val_copy = Line(val.From, val.To)
else:
val_copy = val.Duplicate()
values_copy.append(val_copy)
attr_copy = Attribute(self.name, values_copy, self.transformable)
else:
attr_copy = Attribute(self.name, self.values, self.transformable)
return attr_copy
def compute_next_w_field(self, part):
for i in xrange(len(part.active_connections) - 1, -1, -1):
conn_id = part.active_connections[i]
conn = part.connections[conn_id]
for i2 in xrange(len(conn.active_rules) - 1, -1, -1):
rule_id = conn.active_rules[i2]
rule = conn.rules_table[rule_id]
next_part = self.parts[rule.part2]
next_center = Point3d(next_part.center)
orientTransform = Transform.PlaneToPlane(
next_part.connections[rule.conn2].flip_pln, conn.pln)
next_center.Transform(orientTransform)
if self.multiple_fields:
f_name = next_part.field
if self.field[f_name].bbox.Contains(next_center) == True:
field_val = self.field[f_name].return_pt_val(
next_center)
queue_index = bisect.bisect_left(
self.queue_values, field_val)
queue_entry = (next_part.name, part.id,
orientTransform)
self.queue_values.insert(queue_index, field_val)
self.aggregation_queue.insert(queue_index, queue_entry)
self.queue_count += 1
else:
if self.field.bbox.Contains(next_center) == True:
field_val = self.field.return_pt_val(next_center)
queue_index = bisect.bisect_left(
self.queue_values, field_val)
queue_entry = (next_part.name, part.id,
orientTransform)
self.queue_values.insert(queue_index, field_val)
self.aggregation_queue.insert(queue_index, queue_entry)
self.queue_count += 1
def NurbCrv(P, W, K):
n = 3
P_ = List[Point3d]()
for p in P:
P_.Add(Point3d(p[0], p[1], p[1]))
nc = NurbsCurve.Create(False, n, P_)
for i in range(len(P)):
# cp = ControlPoint()
# cp.X = P[i][0]
# cp.Y = P[i][1]
# cp.Z = P[i][2]
# cp.W = W[i]
w = System.Double(W[i])
cp = ControlPoint(P[i][0], P[i][1], P[i][2], w)
nc.Points[i] = cp
for i in range(nc.Knots.Count):
nc.Knots[i] = K[i]
C = nc
return C
def draw_pipes(pipes, cap=2, fit=1.0):
"""Draw pipes.
Parameters
----------
pipes : list of dict
The pipe definitions.
Other Parameters
----------------
cap : {0, 1, 2}, optional
fit : float, optional
Returns
-------
list of :class:`Rhino.Geometry.Brep`
Notes
-----
.. code-block:: python
Schema({
'points': lambda x: all(len(y) == 3 for y in x),
'radius': And(Or(int, float), lambda x: x > 0)
})
"""
abs_tol = TOL
ang_tol = sc.doc.ModelAngleToleranceRadians
for p in pipes:
points = p['points']
radius = p['radius']
params = [0.0, 1.0]
cap = ToObject(PipeCapMode, cap)
if type(radius) in (int, float):
radius = [radius] * 2
radius = [float(r) for r in radius]
rail = Curve.CreateControlPointCurve([Point3d(*xyz) for xyz in points])
breps = Brep.CreatePipe(rail, params, radius, 1, cap, fit, abs_tol,
ang_tol)
for brep in breps:
yield brep
def transform(self, trans):
if self.transformable == True:
values_trans = []
for val in self.values:
val_trans = None
## !!!! add try..except.. block for other geometry types (?)
if type(val) == Point3d:
val_trans = Point3d(val)
elif type(val) == Plane:
val_trans = Plane(val)
elif type(val) == Line:
val_trans = Line(val.From, val.To)
else:
val_trans = val.Duplicate()
val_trans.Transform(trans)
values_trans.append(val_trans)
attr_trans = Attribute(self.name, values_trans, self.transformable)
else:
attr_trans = Attribute(self.name, self.values, self.transformable)
return attr_trans
def from_data(cls, data):
## recreate empty field
pts_in = []
for pl in data["pts"]:
pts_in.append(Point3d(pl[0], pl[1], pl[2]))
boundaries_in = []
for bl in data["boundaries"]:
boundaries_in.append(mesh_from_dict(bl))
field = cls(data["name"],
pts_in,
data["count"],
data["resolution"],
boundaries=boundaries_in)
## set values
field.set_values(data["values"])
return field
def show(pts):
if rs.IsLayer('Points'):
rs.PurgeLayer('Points')
colors = [pt['color'] for pt in pts]
d_max = sorted(colors)[-1]
for pt in pts:
color = remap(pt['color'], (0, d_max), (0, 255))
rs.AddLayer('Points')
pos = pt['pos']
guid = add_point(Point3d(*pos))
obj = find_object(guid)
attr = obj.Attributes
attr.ObjectColor = FromArgb(color, color, color)
attr.ColorSource = ColorFromObject
index = find_layer_by_fullpath('Points', True)
if index >= 0:
attr.LayerIndex = index
obj.CommitChanges()
