def network_select_vertices(network, message="Select network vertices."):
"""Select vertices of a network.
Parameters
----------
network : compas.datastructures.Network
A network object.
message : str ("Select network vertices.")
The message to display to the user.
Returns
-------
list
The keys of the selected vertices.
Examples
--------
>>>
See Also
--------
* :func:`network_select_vertex`
"""
return VertexSelector.select_vertices(network)
def rhino_vertex_modify_fixity(diagram):
"""Modifies the fixity attribute(s) of selected vertices.
"""
vkeys = VertexSelector.select_vertices(diagram)
go = Rhino.Input.Custom.GetOption()
go.SetCommandPrompt('Set axes Constraints')
boolOptionA = Rhino.Input.Custom.OptionToggle(False, 'False', 'True')
boolOptionX = Rhino.Input.Custom.OptionToggle(False, 'False', 'True')
boolOptionY = Rhino.Input.Custom.OptionToggle(False, 'False', 'True')
boolOptionZ = Rhino.Input.Custom.OptionToggle(False, 'False', 'True')
go.AddOptionToggle('A', boolOptionA)
go.AddOptionToggle('X', boolOptionX)
go.AddOptionToggle('Y', boolOptionY)
go.AddOptionToggle('Z', boolOptionZ)
while True:
opt = go.Get()
if go.CommandResult() != Rhino.Commands.Result.Success:
break
if opt == Rhino.Input.GetResult.Option: # keep picking options
continue
break
if not vkeys:
return
for vkey in vkeys:
if boolOptionA.CurrentValue:
diagram.vertex[vkey]['x_fix'] = True
diagram.vertex[vkey]['y_fix'] = True
diagram.vertex[vkey]['z_fix'] = True
else:
diagram.vertex[vkey]['x_fix'] = boolOptionX.CurrentValue
diagram.vertex[vkey]['y_fix'] = boolOptionY.CurrentValue
diagram.vertex[vkey]['z_fix'] = boolOptionZ.CurrentValue
diagram.draw(layer=diagram.layer)
def mesh_select_vertices(mesh, message="Select mesh vertices."):
"""Select vertices of a mesh.
Parameters
----------
mesh : compas.datastructures.Mesh
A mesh object.
message : str ("Select mesh vertices.")
The message to display to the user.
Returns
-------
list
The keys of the selected vertices.
See Also
--------
* :func:`mesh_select_edges`
* :func:`mesh_select_faces`
"""
return VertexSelector.select_vertices(mesh)
def volmesh_select_vertices(volmesh):
"""Select multiple vertices of a volmesh.
Parameters
----------
volmesh : compas.datastructures.VolMesh
A volmesh object.
Returns
-------
keys : list(int, str, tuple, frozenset)
The identifiers or *keys* of the selected vertices.
Examples
--------
>>> keys = volmesh_select_vertices(volmesh)
See Also
--------
* volmesh_select_vertex
"""
return VertexSelector.select_vertices(volmesh)
for key in mesh.vertices_where({'is_anchor': True})
}
edgecolor = {key: (255, 0, 0) for key in mesh.edges_where({'is_joint': True})}
artist = MeshArtist(mesh, layer="Cablenet")
artist.clear_layer()
artist.draw_vertices(color=vertexcolor)
artist.draw_edges(color=edgecolor)
artist.redraw()
# select mesh vertices
# update the attributes
# redraw mesh if successful
while True:
selected = VertexSelector.select_vertices(mesh)
if not selected:
break
if VertexModifier.update_vertex_attributes(mesh, selected):
artist.clear_layer()
artist.draw_vertices(color=vertexcolor)
artist.draw_edges(color=edgecolor)
# select mesh edges
# update the attributes
# redraw mesh if successful
while True:
selected = EdgeSelector.select_edges(mesh)
if not selected:
break
# give the mesh a name
mesh.attributes['name'] = 'Control'
# set default vertex attributes
mesh.update_default_vertex_attributes({'is_fixed': False})
# make an artist for visualisation
artist = MeshArtist(mesh, layer='SubdModeling::Control')
# draw the control mesh
draw_mesh()
# allow the user to change the attributes of the vertices
while True:
keys = VertexSelector.select_vertices(mesh)
if not keys:
break
VertexModifier.update_vertex_attributes(mesh, keys)
draw_mesh()
# make a subd mesh (using catmullclark)
subd = mesh_subdivide(mesh,
scheme='catmullclark',
k=4,
fixed=mesh.vertices_where({'is_fixed': True}))
# give the subdivision mesh a different name
subd.attributes['name'] = 'Mesh'
# draw the result
def rhino_vertex_move(diagram):
"""Moves the selected vertices.
"""
vkeys = VertexSelector.select_vertices(diagram)
nbr_vkeys = {}
edges = set()
for vkey in vkeys:
all_nbrs = diagram.vertex_neighbors(vkey)
nbrs = []
for nbr in all_nbrs:
if nbr in vkeys:
edges.add(frozenset([vkey, nbr]))
else:
nbrs.append(nbr)
nbr_vkeys[vkey] = nbrs
ip = get_initial_point()
def OnDynamicDraw(sender, e):
cp = e.CurrentPoint
translation = cp - ip
for vkey in vkeys:
xyz = diagram.vertex_coordinates(vkey)
sp = Point3d(*xyz)
for nbr_vkey in nbr_vkeys[vkey]:
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)
ModelAidSettings.Ortho = True
gp = Rhino.Input.Custom.GetPoint()
gp.DynamicDraw += OnDynamicDraw
gp.SetCommandPrompt('Point to move to')
ortho_option = Rhino.Input.Custom.OptionToggle(True, 'Off', 'On')
gp.AddOptionToggle('ortho_snap', ortho_option)
while True:
# ModelAidSettings.Ortho = ortho_option.CurrentValue
get_rc = gp.Get()
gp.SetBasePoint(ip, False)
if gp.CommandResult() != Rhino.Commands.Result.Success:
continue
if get_rc == Rhino.Input.GetResult.Option:
continue
elif get_rc == Rhino.Input.GetResult.Point:
target = gp.Point()
break
translation = target - ip
for vkey in vkeys:
new_xyz = add_vectors(diagram.vertex_coordinates(vkey), translation)
diagram.vertex_update_xyz(vkey, new_xyz, constrained=False)
diagram.draw()
def rhino_vertex_align(diagram):
def update_point(old, new):
if boolOptionA.CurrentValue is True:
return new
if boolOptionX.CurrentValue is True:
old[0] = new[0]
if boolOptionY.CurrentValue is True:
old[1] = new[1]
if boolOptionZ.CurrentValue is True:
old[2] = new[2]
return old
# --------------------------------------------------------------------------
# get vkeys to align
# --------------------------------------------------------------------------
vkeys = VertexSelector.select_vertices(diagram)
nbr_vkeys = {}
edges = set()
for vkey in vkeys:
all_nbrs = diagram.plane[vkey].keys()
nbrs = []
for nbr in all_nbrs:
if nbr in vkeys:
edges.add(frozenset([vkey, nbr]))
else:
nbrs.append(nbr)
nbr_vkeys[vkey] = nbrs
# --------------------------------------------------------------------------
# get rhino point
# --------------------------------------------------------------------------
gp = Rhino.Input.Custom.GetPoint()
gp.SetCommandPrompt('Set alignment Constraints')
boolOptionA = Rhino.Input.Custom.OptionToggle(False, 'False', 'True')
boolOptionX = Rhino.Input.Custom.OptionToggle(False, 'False', 'True')
boolOptionY = Rhino.Input.Custom.OptionToggle(False, 'False', 'True')
boolOptionZ = Rhino.Input.Custom.OptionToggle(False, 'False', 'True')
gp.AddOptionToggle('A', boolOptionA)
gp.AddOptionToggle('X', boolOptionX)
gp.AddOptionToggle('Y', boolOptionY)
gp.AddOptionToggle('Z', boolOptionZ)
def OnDynamicDraw(sender, e):
cp = e.CurrentPoint
for vkey in vkeys:
xyz = diagram.vertex_coordinates(vkey)
sp = Point3d(*xyz)
sp_f = update_point(sp, cp)
for nbr_vkey in nbr_vkeys[vkey]:
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)
while True:
get_rc = gp.Get()
gp.DynamicDraw += OnDynamicDraw
# loop until a point is picked -----------------------------------------
if gp.CommandResult() != Rhino.Commands.Result.Success:
break
if get_rc == Rhino.Input.GetResult.Option: # keep picking options
continue
# loop until a point is picked -----------------------------------------
elif get_rc == Rhino.Input.GetResult.Point:
target = gp.Point()
break
for vkey in vkeys:
xyz = update_point(diagram.vertex_coordinates(vkey), target)
diagram.vertex_update_xyz(vkey, xyz, constrained=False)
diagram.draw()
artist.draw_vertices()
artist.draw_edges()
artist.redraw()
def redraw():
artist.clear_layer()
artist.draw_vertices()
artist.draw_edges()
artist.redraw()
# ==============================================================================
# Vertex attributes
# ==============================================================================
while True:
keys = VertexSelector.select_vertices(shell)
if not keys:
break
if VertexModifier.update_vertex_attributes(shell, keys):
shell.fofin()
redraw()
# ==============================================================================
# Export result
# ==============================================================================
shell.to_json(FILE)
# ==============================================================================
# Visualize result
# ==============================================================================
guids = rs.GetObjects("select polysurfaces", filter=rs.filter.polysurface)
rs.HideObjects(guids)
forcediagram = ForceVolMesh()
forcediagram = volmesh_from_polysurfaces(forcediagram,
guids)
forcediagram.layer = layer
forcediagram.attributes['name'] = layer
forcediagram.draw(layer=layer)
# ------------------------------------------------------------------------------
# 2. pick vertices to fix
# ------------------------------------------------------------------------------
vkeys = VertexSelector.select_vertices(forcediagram,
message='Select vertices to fix:')
# ------------------------------------------------------------------------------
# 3. planarise
# ------------------------------------------------------------------------------
forcediagram.clear()
initial_flatness = volmesh_face_flatness(forcediagram)
# conduit
conduit = VolmeshConduit(forcediagram)
def callback(forcediagram, k, args):
if k % 5: