def save_design(coarse_pseudo_quad_mesh, layer):
"""Save one of the meshes based on the coarse quad mesh.
Parameters
----------
mesh : CoarsePseudoQuadMesh
The coarse quad mesh from which to save data.
"""
mesh_to_save = rs.GetString('mesh to save?',
strings=[
'coarse_pseudo_quad_mesh',
'pseudo_quad_mesh', 'polygonal_mesh'
])
guid = None
if mesh_to_save == 'coarse_pseudo_quad_mesh':
artist = rhino_artist.MeshArtist(coarse_pseudo_quad_mesh)
guid = artist.draw_mesh(coarse_pseudo_quad_mesh)
elif mesh_to_save == 'pseudo_quad_mesh':
artist = rhino_artist.MeshArtist(
coarse_pseudo_quad_mesh.get_quad_mesh())
guid = artist.draw_mesh()
elif mesh_to_save == 'polygonal_mesh':
artist = rhino_artist.MeshArtist(
coarse_pseudo_quad_mesh.get_polygonal_mesh())
guid = artist.draw_mesh()
if guid is not None:
layer = rs.GetLayer(layer=layer)
rs.ObjectLayer(guid, layer)
def editing_geometry_moving(coarse_pseudo_quad_mesh):
"""Edit the geometry of a pattern with moving.
Parameters
----------
coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh
The pattern to edit.
"""
mesh_to_modify = rs.GetString('mesh to modify?',
strings=[
'coarse_pseudo_quad_mesh',
'pseudo_quad_mesh', 'polygonal_mesh'
])
if mesh_to_modify == 'coarse_pseudo_quad_mesh':
mesh = coarse_pseudo_quad_mesh
elif mesh_to_modify == 'pseudo_quad_mesh':
mesh = coarse_pseudo_quad_mesh.get_quad_mesh()
elif mesh_to_modify == 'polygonal_mesh':
mesh = coarse_pseudo_quad_mesh.get_polygonal_mesh()
else:
return 0
while True:
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(mesh)
guid = artist.draw_mesh()
rs.EnableRedraw(True)
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.vertices()})
artist.redraw()
vkeys = rhino_helper.mesh_select_vertices(mesh,
message='vertices to move')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
if vkeys == []:
rs.DeleteObject(guid)
break
rhino_helper.mesh_move_vertices(mesh, vkeys)
rs.DeleteObject(guid)
if mesh_to_modify == 'coarse_pseudo_quad_mesh':
coarse_pseudo_quad_mesh = mesh
elif mesh_to_modify == 'pseudo_quad_mesh':
coarse_pseudo_quad_mesh.set_quad_mesh(mesh)
coarse_pseudo_quad_mesh.set_polygonal_mesh(mesh.copy())
elif mesh_to_modify == 'polygonal_mesh':
coarse_pseudo_quad_mesh.set_polygonal_mesh(mesh)
def add_handle_artist(mesh):
"""Select two mesh faces and add handle.
Parameters
----------
mesh : Mesh
The mesh.
Returns
-------
fkeys
The new face keys from the handle.
"""
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey_1 = rhino_helper.mesh_select_face(mesh, message='fkey_1')
if fkey_1 is not None:
fkey_2 = rhino_helper.mesh_select_face(mesh, message='fkey_2')
if fkey_2 is not None:
fkeys = add_handle(mesh, fkey_1, fkey_2)
else:
fkeys = []
else:
fkeys = []
artist.clear()
rs.DeleteLayer('mesh_artist')
return fkeys
def select_quad_mesh_polyedge(mesh):
"""Select quad mesh polyedge. Selecting one edge is equivalent to selecting one polyedge.
Parameters
----------
mesh : QuadMesh
The quad mesh.
Returns
-------
list
The list of polyedge vertices.
"""
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_edgelabels()
artist.redraw()
edge = rhino_helper.mesh_select_edge(mesh)
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
return mesh.polyedge(*edge)
def select_mesh_polyedge(mesh):
"""Select mesh polyedge.
Parameters
----------
mesh : Mesh
The mesh.
Returns
-------
polyedge : list
The list of polyedge vertices.
"""
# add layer
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
# collect polyedge vertices
polyedge = []
lines = []
while True:
# define candidate vertices for polyedge
if len(polyedge) == 0:
vkey_candidates = mesh.vertices()
else:
vkey_candidates = mesh.vertex_neighbors(polyedge[-1])
# get vertex among candidates
artist.draw_vertexlabels(
text={key: str(key)
for key in vkey_candidates})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vertex')
artist.clear_layer()
artist.redraw()
# stop if no vertex is added
if vkey is None:
break
# add vertex to polyedge
polyedge.append(vkey)
if len(polyedge) > 1:
u = mesh.vertex_coordinates(polyedge[-2])
v = mesh.vertex_coordinates(polyedge[-1])
guid = rs.AddLine(u, v)
rs.ObjectColor(guid, [255, 255, 0])
lines.append(guid)
rs.DeleteLayer('mesh_artist')
rs.DeleteObjects(lines)
return polyedge
def editing_topology(coarse_pseudo_quad_mesh):
"""Edit the topology of a pattern, i.e. its singularities, via its strips.
Parameters
----------
coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh
The pattern to edit.
"""
while True:
# update drawing
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(coarse_pseudo_quad_mesh)
guid = artist.draw_mesh()
rs.EnableRedraw(True)
# choose operation
operation = rs.GetString('edit strip topology?',
strings=['add', 'delete', 'split', 'exit'])
# stop if asked
if operation is None or operation == 'exit':
rs.DeleteObject(guid)
break
# apply operation
if operation == 'add':
skey = add_strip(coarse_pseudo_quad_mesh,
select_mesh_polyedge(coarse_pseudo_quad_mesh))[0]
coarse_pseudo_quad_mesh.set_strip_density(skey, 1)
elif operation == 'delete':
skeys = set(select_quad_mesh_strips(coarse_pseudo_quad_mesh))
skey_to_skeys = delete_strips(coarse_pseudo_quad_mesh, skeys)
if skey_to_skeys is not None:
for skey_0, skeys in skey_to_skeys.items():
d = int(
ceil(
float(
coarse_pseudo_quad_mesh.get_strip_density(
skey_0)) / 2.))
coarse_pseudo_quad_mesh.set_strips_density(d, skeys)
elif operation == 'split':
skey = select_quad_mesh_strip(coarse_pseudo_quad_mesh)
n = rs.GetInteger('number of splits', number=2, minimum=2)
skeys = split_strip(coarse_pseudo_quad_mesh, skey, n=n)
# update data
d = int(
ceil(
float(coarse_pseudo_quad_mesh.get_strip_density(skey)) /
float(n)))
coarse_pseudo_quad_mesh.set_strips_density(d, skeys)
# delete drawing
rs.DeleteObject(guid)
def select_mesh_polyedge(mesh):
"""Select polyedge vertices via artist.
Parameters
----------
mesh : Mesh
The mesh.
Returns
-------
polyedge : list
The list of polyedge vertices.
"""
# add layer
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
# collect polyedge vertices
polyedge = []
count = mesh.number_of_vertices() + 1
while count > 0:
count -= 1
# define candidate vertices ofr polyedge
if len(polyedge) == 0:
vkey_candidates = mesh.vertices()
else:
vkey_candidates = mesh.vertex_neighbors(polyedge[-1])
# get vertex among candidates
artist.draw_vertexlabels(text={
key: str(key)
for key in vkey_candidates if key not in polyedge[1:]
})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vertex')
artist.clear_layer()
artist.redraw()
# stop if no vertex is added
if vkey is None:
break
# add vertex to polyedge
polyedge.append(vkey)
# stop if polyedge is closed
if len(polyedge) != 1 and vkey == polyedge[0]:
break
rs.DeleteLayer('mesh_artist')
return polyedge
def editing_symmetry(coarse_pseudo_quad_mesh):
"""Edit the symmetry of a pattern via Conway operators.
Parameters
----------
coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh
The pattern to edit.
"""
conway_operators = {
'conway_seed', 'conway_dual', 'conway_join', 'conway_ambo',
'conway_kis', 'conway_needle', 'conway_zip', 'conway_truncate',
'conway_ortho', 'conway_expand', 'conway_gyro', 'conway_snub',
'conway_meta', 'conway_bevel'
}
conway = {operator[7:]: operator for operator in conway_operators}
while True:
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(
coarse_pseudo_quad_mesh.get_polygonal_mesh())
guid = artist.draw_mesh()
rs.EnableRedraw(True)
operator = rs.GetString('Conway operator?',
strings=conway.keys() + ['exit'])
if operator is None or operator == 'exit':
if type(guid) == list:
rs.DeleteObjects(guid)
else:
rs.DeleteObject(guid)
return coarse_pseudo_quad_mesh.get_polygonal_mesh()
elif operator == 'seed':
coarse_pseudo_quad_mesh.set_polygonal_mesh(
coarse_pseudo_quad_mesh.get_quad_mesh().copy())
elif operator in conway and conway[operator] in globals() and str(
conway[operator])[:6] == 'conway':
coarse_pseudo_quad_mesh.set_polygonal_mesh(
globals()[conway[operator]](
coarse_pseudo_quad_mesh.get_polygonal_mesh()))
if type(guid) == list:
rs.DeleteObjects(guid)
else:
rs.DeleteObject(guid)
def custom_constraints(mesh, surface):
from compas_pattern.cad.rhino.utilities import surface_borders
#surface_boundaries = surface_borders(surface, border_type = 0)
rs.EnableRedraw(True)
surface_boundaries = rs.GetObjects('surface boundaries', filter=4)
rs.EnableRedraw(False)
constraints = {}
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
vertex_points = {
rs.AddPoint(mesh.vertex_coordinates(vkey)): vkey
for vkey in mesh.vertices()
}
rs.EnableRedraw(True)
fixed_vertices = rs.GetObjects('fixed vertices', filter=1)
if fixed_vertices is None:
fixed_vertices = []
vkeys = [vertex_points[vkey] for vkey in fixed_vertices]
rs.DeleteObjects(vertex_points)
rs.EnableRedraw(False)
#artist.draw_vertexlabels()
#artist.redraw()
#vkeys = rhino.mesh_select_vertices(mesh, message = 'fixed vertices')
#artist.clear_layer()
#artist.redraw()
for vkey in vkeys:
if vkey not in constraints:
constraints[vkey] = ('fixed', mesh.vertex_coordinates(vkey))
# collect boundayr polylines with splits
from compas_pattern.topology.polyline_extraction import mesh_boundaries
mesh_boundaries = mesh_boundaries(mesh)
split_vertices = [
vkey for vkey, constraint in constraints.items()
if constraint[0] == 'fixed'
]
# add one vertex per mesh boundary element that has no split vertices yet, i.e. that has no corner vertices (2-valency)
for boundary in mesh_boundaries:
to_add = True
for vkey in boundary:
if vkey in split_vertices:
to_add = False
break
if to_add:
split_vertices.append(boundary[0])
split_mesh_boundaries = []
while len(split_vertices) > 0:
start = split_vertices.pop()
# exception if split vertex corresponds to a non-boundary point feature
if not mesh.is_vertex_on_boundary(start):
continue
polyline = [start]
while 1:
for nbr, fkey in iter(mesh.halfedge[polyline[-1]].items()):
if fkey is None:
polyline.append(nbr)
break
# end of boundary element
if start == polyline[-1]:
split_mesh_boundaries.append(polyline)
break
# end of boundary subelement
elif polyline[-1] in split_vertices:
split_mesh_boundaries.append(polyline)
split_vertices.remove(polyline[-1])
polyline = polyline[-1:]
srf_dots = {
rs.AddTextDot('srf_boundary', rs.CurveMidPoint(srf_bdry)): srf_bdry
for srf_bdry in surface_boundaries
}
for mesh_bdry in split_mesh_boundaries:
if len(mesh_bdry) == 2:
xyz = mesh.edge_midpoint(mesh_bdry[0], mesh_bdry[1])
else:
idx = int(math.floor(len(mesh_bdry) / 2))
xyz = mesh.vertex_coordinates(mesh_bdry[idx])
mesh_dot = rs.AddTextDot('?', xyz)
rs.EnableRedraw(True)
crv_cstr = srf_dots[rs.GetObject('boundary constraint', filter=8192)]
rs.EnableRedraw(False)
for vkey in mesh_bdry:
if vkey not in constraints:
constraints[vkey] = ('curve', crv_cstr)
rs.DeleteObject(mesh_dot)
rs.EnableRedraw(True)
rs.DeleteObjects(srf_dots)
rs.EnableRedraw(False)
for vkey in mesh.vertices():
if vkey not in constraints:
constraints[vkey] = ('surface', surface)
return constraints, surface_boundaries
def singular():
"""Explore a pattern, its topology (singularities, densities and symmetries) and its geoemtry (via smoothing).
"""
layer = rs.CurrentLayer()
pattern_from = rs.GetString('start pattern from?',
strings=[
'coarse_pseudo_quad_mesh',
'pseudo_quad_mesh', 'surface_and_features'
])
if pattern_from == 'coarse_pseudo_quad_mesh':
guid = rs.GetObject('get coarse quad mesh', filter=32)
vertices, faces = RhinoMesh.from_guid(guid).get_vertices_and_faces()
clean_faces(faces)
poles = []
#print(faces)
for face in faces:
if len(face) != 4:
poles = [
rs.PointCoordinates(point)
for point in rs.GetObjects('get pole points', filter=1)
]
break
coarse_pseudo_quad_mesh = CoarsePseudoQuadMesh.from_vertices_and_faces_with_poles(
vertices, faces, poles)
coarse_pseudo_quad_mesh.collect_strips()
print(coarse_pseudo_quad_mesh.data['attributes']['strips'])
coarse_pseudo_quad_mesh.set_strips_density(1)
coarse_pseudo_quad_mesh.set_quad_mesh(coarse_pseudo_quad_mesh.copy())
coarse_pseudo_quad_mesh.set_polygonal_mesh(
coarse_pseudo_quad_mesh.copy())
print(coarse_pseudo_quad_mesh.data['attributes']['strips'])
elif pattern_from == 'pseudo_quad_mesh':
guid = rs.GetObject('get quad mesh', filter=32)
vertices, faces = RhinoMesh.from_guid(guid).get_vertices_and_faces()
clean_faces(faces)
poles = []
for face in faces:
if len(face) != 4:
poles = [
rs.PointCoordinates(point)
for point in rs.GetObjects('get pole points', filter=1)
]
break
coarse_pseudo_quad_mesh = CoarsePseudoQuadMesh.from_quad_mesh(
PseudoQuadMesh.from_vertices_and_faces_with_poles(
vertices, faces, poles))
elif pattern_from == 'surface_and_features':
srf_guid = rs.GetObject('get surface', filter=8)
crv_guids = rs.GetObjects('get optional curve features', filter=4)
if crv_guids is None:
crv_guids = []
pt_guids = rs.GetObjects('get optional point features', filter=1)
if pt_guids is None:
pt_guids = []
coarse_pseudo_quad_mesh = surface_decomposition(
srf_guid,
rs.GetReal('precision', number=1.),
crv_guids=crv_guids,
pt_guids=pt_guids,
output_skeleton=False)[0]
coarse_pseudo_quad_mesh.collect_strips()
coarse_pseudo_quad_mesh.set_strips_density(1)
coarse_pseudo_quad_mesh.set_quad_mesh(coarse_pseudo_quad_mesh.copy())
coarse_pseudo_quad_mesh.set_polygonal_mesh(
coarse_pseudo_quad_mesh.copy())
artist = rhino_artist.MeshArtist(coarse_pseudo_quad_mesh)
guid = artist.draw_mesh()
else:
return 0
while True:
#edit = rs.GetString('edit pattern?', strings = ['topology', 'density', 'symmetry', 'geometry', 'evaluate', 'exit'])
edit = rs.GetString('edit pattern?',
strings=[
'topology', 'density', 'symmetry', 'geometry',
'save', 'exit'
])
if type(guid) == list:
rs.DeleteObjects(guid)
else:
rs.DeleteObject(guid)
if edit is None or edit == 'exit':
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(
coarse_pseudo_quad_mesh.get_polygonal_mesh())
return artist.draw_mesh()
if edit == 'topology':
editing_topology(coarse_pseudo_quad_mesh)
coarse_pseudo_quad_mesh.densification()
coarse_pseudo_quad_mesh.set_polygonal_mesh(
coarse_pseudo_quad_mesh.get_quad_mesh().copy())
elif edit == 'density':
editing_density(coarse_pseudo_quad_mesh)
coarse_pseudo_quad_mesh.set_polygonal_mesh(
coarse_pseudo_quad_mesh.get_quad_mesh().copy())
elif edit == 'symmetry':
editing_symmetry(coarse_pseudo_quad_mesh)
elif edit == 'geometry':
editing_geometry(coarse_pseudo_quad_mesh)
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(
coarse_pseudo_quad_mesh.get_polygonal_mesh())
guid = artist.draw_mesh()
rs.EnableRedraw(True)
if edit == 'save':
save_design(coarse_pseudo_quad_mesh, layer)
if edit == 'evaluate':
evaluate_pattern(coarse_pseudo_quad_mesh.get_polygonal_mesh())
def editing_geometry_smoothing(coarse_pseudo_quad_mesh):
"""Edit the geometry of a pattern with smoothing.
Parameters
----------
coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh
The pattern to edit.
"""
mesh_to_smooth = rs.GetString('mesh to smooth?',
strings=[
'coarse_pseudo_quad_mesh',
'pseudo_quad_mesh', 'polygonal_mesh'
])
if mesh_to_smooth == 'coarse_pseudo_quad_mesh':
mesh = coarse_pseudo_quad_mesh
elif mesh_to_smooth == 'pseudo_quad_mesh':
mesh = coarse_pseudo_quad_mesh.get_quad_mesh
elif mesh_to_smooth == 'polygonal_mesh':
mesh = coarse_pseudo_quad_mesh.get_polygonal_mesh()
else:
return 0
settings = {'iterations': 50, 'damping': .5, 'constraints': {}}
while True:
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(mesh)
guid = artist.draw_mesh()
rs.EnableRedraw(True)
operation = rs.GetString(
'edit smoothing settings?',
strings=['smooth', 'iterations', 'damping', 'constraints', 'exit'])
if operation is None or operation == 'exit':
if type(guid) == list:
rs.DeleteObjects(guid)
else:
rs.DeleteObject(guid)
break
elif operation == 'iterations':
settings[operation] = rs.GetInteger('iterations',
number=settings[operation],
minimum=0)
elif operation == 'damping':
settings[operation] = rs.GetReal('damping',
number=settings[operation],
minimum=0.,
maximum=1.)
elif operation == 'constraints':
count = 100
while count:
count -= 1
guids = display_smoothing_constraints(mesh,
settings[operation])
constraint_type = rs.GetString('type of constraints?',
strings=[
'automated_from_surface',
'automated_from_objects',
'customised', 'reset',
'exit'
])
rs.DeleteObjects(guids)
if constraint_type == 'automated_from_surface':
settings[
operation] = automated_smoothing_surface_constraints(
mesh,
RhinoSurface(
rs.GetObject('surface constraints', filter=8)))
elif constraint_type == 'automated_from_objects':
object_constraints = rs.GetObjects('object constraints')
point_constraints = [
obj for obj in object_constraints
if rs.ObjectType(obj) == 1
]
curve_constraints = [
obj for obj in object_constraints
if rs.ObjectType(obj) == 4
]
surface_constraint = [
obj for obj in object_constraints
if rs.ObjectType(obj) == 8
]
if len(surface_constraint) > 1:
print(
'More than one surface constraint! Only the first one is taken into account.'
)
if len(surface_constraint) == 0:
surface_constraint = None
else:
surface_constraint = surface_constraint[0]
settings[operation] = automated_smoothing_constraints(
mesh, point_constraints, curve_constraints,
surface_constraint)
elif constraint_type == 'customised':
settings[operation] = customized_smoothing_constraints(
mesh, settings[operation])
elif constraint_type == 'reset':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_vertices()
artist.redraw()
vkeys = rhino_helper.mesh_select_vertices(
mesh, message='vertices')
if vkeys is None:
vkeys = list(mesh.vertices())
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
for vkey in vkeys:
if vkey in settings[operation]:
del settings[operation][vkey]
else:
break
elif operation == 'smooth':
constrained_smoothing(mesh,
kmax=settings['iterations'],
damping=settings['damping'],
constraints=settings['constraints'],
algorithm='area')
if type(guid) == list:
rs.DeleteObjects(guid)
else:
rs.DeleteObject(guid)
if mesh_to_smooth == 'coarse_pseudo_quad_mesh':
coarse_pseudo_quad_mesh = mesh
elif mesh_to_smooth == 'pseudo_quad_mesh':
coarse_pseudo_quad_mesh.set_quad_mesh(mesh)
coarse_pseudo_quad_mesh.set_polygonal_mesh(mesh.copy())
elif mesh_to_smooth == 'polygonal_mesh':
coarse_pseudo_quad_mesh.set_polygonal_mesh(mesh)
def editing_density(coarse_pseudo_quad_mesh):
"""Edit the density of a pattern via its strip densities.
Parameters
----------
coarse_pseudo_quad_mesh : CoarsePseudoQuadMesh
The pattern to edit.
"""
while True:
# update drawing
rs.EnableRedraw(False)
artist = rhino_artist.MeshArtist(
coarse_pseudo_quad_mesh.get_quad_mesh())
guid = artist.draw_mesh()
rs.EnableRedraw(True)
# choose operation
operation = rs.GetString(
'edit strip density?',
strings=[
'global_density_value', 'global_subdivision_target_length',
'strip_density_value', 'strip_subdivision_target_length',
'global_uniform_target_number_faces', 'exit'
])
# stop if asked
if operation is None or operation == 'exit':
rs.DeleteObjects(guid)
break
# get operation parameters
if 'strip' in operation:
skey = select_quad_mesh_strip(coarse_pseudo_quad_mesh,
text='density')
print(skey)
print(coarse_pseudo_quad_mesh.data['attributes']['strips'])
if 'value' in operation:
d = rs.GetInteger('density value', number=3, minimum=1)
elif 'length' in operation:
t = rs.GetReal('density target', number=1.)
elif 'faces' in operation:
nb_faces = rs.GetInteger('density value', number=100, minimum=1)
# apply operation
if operation == 'strip_density_value':
coarse_pseudo_quad_mesh.set_strip_density(skey, d)
elif operation == 'global_density_value':
coarse_pseudo_quad_mesh.set_strips_density(d)
elif operation == 'strip_subdivision_target_length':
coarse_pseudo_quad_mesh.set_strip_density_target(skey, t)
elif operation == 'global_subdivision_target_length':
coarse_pseudo_quad_mesh.set_strips_density_target(t)
elif operation == 'global_uniform_target_number_faces':
coarse_pseudo_quad_mesh.set_strips_density_equal_face_target(
nb_faces)
# update data
coarse_pseudo_quad_mesh.densification()
# delete drawing
rs.DeleteObjects(guid)
def apply_rule(mesh, rule):
if rule == 'face_pole':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
face_pole(mesh, fkey)
elif rule == 'edge_pole':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_edgelabels(text={(u, v): "{}-{}".format(u, v)
for u, v in mesh.face_halfedges(fkey)})
artist.redraw()
edge = rhino_helper.mesh_select_edge(mesh, message='edge')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
edge_pole(mesh, fkey, edge)
elif rule == 'vertex_pole':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.face_vertices(fkey)})
artist.redraw()
pole = rhino_helper.mesh_select_vertex(mesh, message='pole')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
vertex_pole(mesh, fkey, pole)
elif rule == 'add_opening':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
face_opening(mesh, fkey)
elif rule == 'close_opening':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
boundaries = mesh_boundaries(mesh)
artist.draw_vertexlabels(
text={
key: str(key)
for key in
[vkey for boundary in boundaries for vkey in boundary]
})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(
mesh, message='vertex on the opening to close')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
for boundary in boundaries:
if vkey in boundary:
vkeys = boundary
break
close_opening(mesh, vkeys)
elif rule == 'flat_corner_2':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.face_vertices(fkey)})
artist.redraw()
corner = rhino_helper.mesh_select_vertex(mesh, message='corner')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
flat_corner_2(mesh, fkey, corner)
elif rule == 'flat_corner_3':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.face_vertices(fkey)})
artist.redraw()
corner = rhino_helper.mesh_select_vertex(mesh, message='corner')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
flat_corner_3(mesh, fkey, corner)
elif rule == 'flat_corner_33':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.face_vertices(fkey)})
artist.redraw()
corner = rhino_helper.mesh_select_vertex(mesh, message='corner')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
flat_corner_33(mesh, fkey, corner)
elif rule == 'split_35':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_edgelabels(text={(u, v): "{}-{}".format(u, v)
for u, v in mesh.face_halfedges(fkey)})
artist.redraw()
edge = rhino_helper.mesh_select_edge(mesh, message='edge')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
split_35(mesh, fkey, edge)
elif rule == 'split_35_diag':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.face_vertices(fkey)})
artist.redraw()
corner = rhino_helper.mesh_select_vertex(mesh, message='corner')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
split_35_diag(mesh, fkey, corner)
elif rule == 'split_26':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_edgelabels(text={(u, v): "{}-{}".format(u, v)
for u, v in mesh.face_halfedges(fkey)})
artist.redraw()
edge = rhino_helper.mesh_select_edge(mesh, message='edge')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
split_26(mesh, fkey, edge)
elif rule == 'simple_split':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_edgelabels(text={(u, v): "{}-{}".format(u, v)
for u, v in mesh.face_halfedges(fkey)})
artist.redraw()
edge = rhino_helper.mesh_select_edge(mesh, message='edge')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
simple_split(mesh, fkey, edge)
elif rule == 'double_split':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
double_split(mesh, fkey)
elif rule == 'insert_pole':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.face_vertices(fkey)})
artist.redraw()
pole = rhino_helper.mesh_select_vertex(mesh, message='pole')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
insert_pole(mesh, fkey, pole)
elif rule == 'insert_partial_pole':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.face_vertices(fkey)})
artist.redraw()
pole = rhino_helper.mesh_select_vertex(mesh, message='pole')
artist.clear_layer()
artist.redraw()
artist.draw_edgelabels({(u, v): "{}-{}".format(u, v)
for u, v in mesh.face_halfedges(fkey)
if u != pole and v != pole})
artist.redraw()
edge = rhino_helper.mesh_select_edge(mesh, message='edge')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
insert_partial_pole(mesh, fkey, pole, edge)
elif rule == 'singular_boundary_1':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_edgelabels(text={(u, v): "{}-{}".format(u, v)
for u, v in mesh.edges()})
artist.redraw()
edge = rhino_helper.mesh_select_edge(mesh, message='edge')
artist.clear_layer()
artist.redraw()
artist.draw_vertexlabels(text={key: str(key) for key in edge})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vkey')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
singular_boundary_1(mesh, edge, vkey)
elif rule == 'singular_boundary_2':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_edgelabels(text={(u, v): "{}-{}".format(u, v)
for u, v in mesh.edges()})
artist.redraw()
edge = rhino_helper.mesh_select_edge(mesh, message='edge')
artist.clear_layer()
artist.redraw()
artist.draw_vertexlabels(text={key: str(key) for key in edge})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vkey')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
singular_boundary_2(mesh, edge, vkey)
elif rule == 'singular_boundary_minus_1':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey = rhino_helper.mesh_select_face(mesh, message='fkey')
artist.clear_layer()
artist.redraw()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.face_vertices(fkey)})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vkey')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
singular_boundary_minus_1(mesh, fkey, vkey)
elif rule == 'face_strip_collapse':
edge_groups, max_group = dual_edge_polylines(mesh)
groups = {}
for edge, group in edge_groups.items():
u, v = edge
if group in groups:
if (v, u) not in groups[group]:
groups[group].append((u, v))
else:
groups[group] = [(u, v)]
rs.EnableRedraw(False)
dots = {}
for group, edges in groups.items():
k = float(group) / float(max_group) * 255
RGB = [k] * 3
rs.AddGroup(group)
for u, v in edges:
dot = rs.AddTextDot(group, mesh.edge_midpoint(u, v))
dots[dot] = (u, v)
rs.ObjectColor(dot, RGB)
rs.AddObjectToGroup(dot, group)
rs.EnableRedraw(True)
dot = rs.GetObject('dual polyedge to collapse', filter=8192)
u, v = dots[dot]
rs.DeleteObjects(dots)
face_strip_collapse(PseudoQuadMesh, mesh, u, v)
elif rule == 'face_strip_insert':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
count = mesh.number_of_vertices() * 1.5
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.vertices_on_boundary()})
artist.redraw()
vertex_path = [rhino_helper.mesh_select_vertex(mesh, message='vertex')]
artist.clear_layer()
count = mesh.number_of_vertices() * 1.5
while count > 0:
count -= 1
artist.draw_vertexlabels(text={
key: str(key)
for key in mesh.vertex_neighbors(vertex_path[-1])
})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vertex')
artist.clear_layer()
artist.redraw()
if vkey is None:
break
else:
vertex_path.append(vkey)
rs.DeleteLayer('mesh_artist')
#start_pole = rs.GetInteger(message='pole at the start?', number=0, minimum=0, maximum=1)
#end_pole = rs.GetInteger(message='pole at the end?', number=0, minimum=0, maximum=1)
start_pole = 0
end_pole = 0
mesh = face_strip_insert(PseudoQuadMesh,
mesh,
vertex_path,
pole_extremities=[start_pole, end_pole])
elif rule == 'rotate_vertex':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.vertices()})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vkey')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
rotate_vertex(mesh, vkey)
elif rule == 'clear_faces':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkeys = rhino_helper.mesh_select_faces(mesh, message='fkeys')
artist.clear_layer()
artist.redraw()
vertices = [mesh.vertex_coordinates(vkey) for vkey in mesh.vertices()]
face_vertices = [mesh.face_vertices(fkey) for fkey in fkeys]
faces_mesh = PseudoQuadMesh.from_vertices_and_faces(
vertices, face_vertices)
faces_boundary_vertices = mesh_boundaries(faces_mesh)[0]
artist.draw_vertexlabels(
text={key: str(key)
for key in faces_boundary_vertices})
artist.redraw()
vkeys = rhino_helper.mesh_select_vertices(mesh, message='vkeys')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
clear_faces(mesh, fkeys, vkeys)
elif rule == 'add_handle':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey_1 = rhino_helper.mesh_select_face(mesh, message='fkey_1')
artist.clear_layer()
artist.redraw()
artist.draw_facelabels()
artist.redraw()
fkey_2 = rhino_helper.mesh_select_face(mesh, message='fkey_2')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
add_handle(mesh, fkey_1, fkey_2)
elif rule == 'close_handle':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_facelabels()
artist.redraw()
fkey_1 = rhino_helper.mesh_select_face(mesh, message='fkey_1')
artist.clear_layer()
artist.redraw()
artist.draw_facelabels(
text={key: str(key)
for key in mesh.face_neighbors(fkey_1)})
artist.redraw()
fkey_2 = rhino_helper.mesh_select_face(mesh, message='fkey_2')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
count = mesh.number_of_faces()
fkeys = [fkey_1, fkey_2]
while count > 0:
count -= 1
u, v = mesh.face_adjacency_halfedge(fkeys[-2], fkeys[-1])
w = mesh.face_vertex_ancestor(fkeys[-1], v)
x = mesh.face_vertex_ancestor(fkeys[-1], w)
if x in mesh.halfedge[w] and mesh.halfedge[w][x] is not None:
fkey_3 = mesh.halfedge[w][x]
fkeys.append(fkey_3)
if fkeys[-1] == fkeys[0]:
break
close_handle(mesh, fkeys)
elif rule == 'close_handle_2':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
edge_paths = []
for i in range(2):
vertex_path = []
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.vertices()})
artist.redraw()
vertex_path.append(
rhino_helper.mesh_select_vertex(mesh, message='vertex'))
artist.clear_layer()
artist.redraw()
count = mesh.number_of_vertices()
while count > 0:
count -= 1
artist.draw_vertexlabels(
text={
key: str(key)
for key in mesh.vertex_neighbors(vertex_path[-1])
})
artist.redraw()
vkey = rhino_helper.mesh_select_vertex(mesh, message='vertex')
if vkey is None:
break
artist.clear_layer()
artist.redraw()
if vkey in list(mesh.vertices()):
vertex_path.append(vkey)
else:
break
if vkey == vertex_path[0]:
break
del vertex_path[-1]
edge_paths.append([[vertex_path[i - 1], vertex_path[i]]
for i in range(len(vertex_path))])
rs.DeleteLayer('mesh_artist')
edge_path_1, edge_path_2 = edge_paths
mesh = close_handle_2(mesh, edge_path_1, edge_path_2)
elif rule == 'move_vertices':
artist = rhino_artist.MeshArtist(mesh, layer='mesh_artist')
artist.clear_layer()
artist.draw_vertexlabels(
text={key: str(key)
for key in mesh.vertices()})
artist.redraw()
vkeys = rhino_helper.mesh_select_vertices(mesh, message='vkeys')
artist.clear_layer()
artist.redraw()
rs.DeleteLayer('mesh_artist')
x1, y1, z1 = rs.GetPoint(message='from...')
x2, y2, z2 = rs.GetPoint(message='...to')
for vkey in vkeys:
attr = mesh.vertex[vkey]
attr['x'] += x2 - x1
attr['y'] += y2 - y1
attr['z'] += z2 - z1
elif rule == 'project_on_surface':
srf = rs.GetObject('surface for projection', filter=8)
for vkey in mesh.vertices():
u, v = rs.SurfaceClosestPoint(srf, mesh.vertex_coordinates(vkey))
x, y, z = rs.EvaluateSurface(srf, u, v)
attr = mesh.vertex[vkey]
attr['x'] = x
attr['y'] = y
attr['z'] = z
return 0