def gh_surface_decomposition(surface_guid, accuracy_value, point_guids, curve_guids): if point_guids == [None]: point_guids = [] if curve_guids == [None]: curve_guids = [] outer_boundary, inner_boundaries, polyline_features, point_features = surface_discrete_mapping(surface_guid, accuracy_value, crv_guids = curve_guids, pt_guids = point_guids) tri_mesh = boundary_triangulation(outer_boundary, inner_boundaries, polyline_features, point_features) decomposition = SkeletonDecomposition.from_mesh(tri_mesh) quad_mesh = decomposition.decomposition_mesh(point_features) RhinoSurface.from_guid(surface_guid).mesh_uv_to_xyz(quad_mesh) return quad_mesh
def gh_surface_skeleton(surface_guid, accuracy_value, point_guids, curve_guids): if point_guids == [None]: point_guids = [] if curve_guids == [None]: curve_guids = [] outer_boundary, inner_boundaries, polyline_features, point_features = surface_discrete_mapping(surface_guid, accuracy_value, crv_guids = curve_guids, pt_guids = point_guids) tri_mesh = boundary_triangulation(outer_boundary, inner_boundaries, polyline_features, point_features) skeleton = Skeleton.from_mesh(tri_mesh) branches = skeleton.branches() polylines = [rs.AddPolyline(RhinoSurface.from_guid(surface_guid).polyline_uv_to_xyz([point[:2] for point in branch])) for branch in branches] return polylines
from compas_singular.algorithms import SkeletonDecomposition
from compas_plotters.meshplotter import MeshPlotter
# read input data
filepath = 'data/01_decomposition.json'
with open(filepath, 'r') as fp:
data = json.load(fp)
# get outer boundary polyline, inner boundary polylines, polyline features and point features
outer_boundary, inner_boundaries, polyline_features, point_features = data
# Delaunay triangulation of the surface formed by the planar polylines using the points as Delaunay vertices
mesh = boundary_triangulation(outer_boundary,
inner_boundaries,
polyline_features,
point_features,
src='numpy')
# start instance for skeleton-based decomposition
decomposition = SkeletonDecomposition.from_mesh(mesh)
# # build decomposition mesh
mesh = decomposition.decomposition_mesh(point_features)
# plot decomposition mesh
plotter = MeshPlotter(mesh, figsize=(5, 5))
plotter.draw_edges()
plotter.draw_vertices()
plotter.draw_faces()
plotter.show()
def from_surface_and_features(cls,
discretisation,
target_edge_length,
surf_guid,
curve_guids=[],
point_guids=[],
delaunay=None):
"""Get a pattern object from a NURBS surface with optional point and curve features on the surface.
The pattern is aligned to the surface boundaries and curve features.
The pattern contains a pole singularity at the feature points. Pole singularities are a specific type of singularity.
Parameters
----------
discretisation : float
The surface boundary and curve feature discretisation length.
Values between 1% and 5% of the length of the diagonal of the bounding box are recommended.
target_edge_length : float
The edge target length for densification.
surf_guid : str
A Rhino surface guid.
curves : list of str, optional
A list of Rhino curve guids.
points : list of str, optional
A list of Rhino point guids.
Returns
-------
Pattern
A Pattern object.
References
----------
Based on [1]_ and [2]_.
.. [1] Oval et al. *Feature-based topology finding of patterns for shell structures*. Automation in Construction, 2019.
Available at: https://www.researchgate.net/publication/331064073_Feature-based_Topology_Finding_of_Patterns_for_Shell_Structures.
.. [2] Oval. *Topology finding of patterns for structural design*. PhD thesis, Unversite Paris-Est, 2019.
Available at: https://www.researchgate.net/publication/340096530_Topology_Finding_of_Patterns_for_Structural_Design.
"""
from compas_singular.rhino import RhinoSurface
AddInterpCrvOnSrfUV = compas_rhino.rs.AddInterpCrvOnSrfUV
compas_rhino.rs.EnableRedraw(False)
surface = RhinoSurface.from_guid(surf_guid)
result = surface.discrete_mapping(discretisation,
crv_guids=curve_guids,
pt_guids=point_guids)
outer_boundary, inner_boundaries, polyline_features, point_features = result
trimesh = boundary_triangulation(*result, delaunay=delaunay)
decomposition = SkeletonDecomposition.from_mesh(trimesh)
coarsemesh = decomposition.decomposition_mesh(point_features)
gkey_vertex = {
geometric_key(coarsemesh.vertex_coordinates(vertex)): vertex
for vertex in coarsemesh.vertices()
}
edge_curve = {}
for polyline in decomposition.polylines:
a = geometric_key(polyline[0])
b = geometric_key(polyline[-1])
u = gkey_vertex[a]
v = gkey_vertex[b]
points = [point[:2] for point in polyline]
curve = AddInterpCrvOnSrfUV(surf_guid, points)
edge_curve[u, v] = curve
coarsemesh.collect_strips()
coarsemesh.set_strips_density_target(target_edge_length)
coarsemesh.densification(edges_to_curves=edge_curve)
compas_rhino.delete_objects(edge_curve.values(), purge=True)
densemesh = coarsemesh.get_quad_mesh()
compas_rhino.rs.EnableRedraw(True)
compas_rhino.rs.Redraw()
return cls.from_vertices_and_faces(*densemesh.to_vertices_and_faces())
def from_surface_and_features(cls,
input_subdivision_spacing,
mesh_edge_length,
srf_guid,
crv_guids=[],
pt_guids=[],
delaunay=None):
"""Get a pattern object from a NURBS surface with optional point and curve features on the surface.
The pattern is aligned to the surface boundaries and curve features.
The pattern contains a pole singularity at the feature points. Pole singularities are a specific type of singularity.
Parameters
----------
input_subdivision_spacing : float
The surface boundary and curve feature subdivision spacing. Values between 0.01 and 0.05 of the length of the diagonal of the bounding box are recommended.
mesh_edge_length : float
The edge target length for densification.
srf_guid : Rhino surface guid
A Rhino surface guid.
crv_guids : list, []
Optional. A list of Rhino curve guids.
pt_guids : list, []
Optional. A list of Rhino point guids. WIP
Returns
-------
Pattern
A Pattern object.
References
----------
Based on [1]_ and [2]_.
.. [1] Oval et al. *Feature-based topology finding of patterns for shell structures*. Automation in Construction, 2019.
Available at: https://www.researchgate.net/publication/331064073_Feature-based_Topology_Finding_of_Patterns_for_Shell_Structures.
.. [2] Oval. *Topology finding of patterns for structural design*. PhD thesis, Unversite Paris-Est, 2019.
Available at: https://www.researchgate.net/publication/340096530_Topology_Finding_of_Patterns_for_Structural_Design.
"""
outer_boundary, inner_boundaries, polyline_features, point_features = surface_discrete_mapping(
srf_guid,
input_subdivision_spacing,
crv_guids=crv_guids,
pt_guids=pt_guids)
tri_mesh = boundary_triangulation(outer_boundary, inner_boundaries,
polyline_features, point_features,
delaunay)
decomposition = SkeletonDecomposition.from_mesh(tri_mesh)
coarse_mesh = decomposition.decomposition_mesh(point_features)
polylines = decomposition.polylines
nurbs_curves = {
(geometric_key(polyline[0]), geometric_key(polyline[-1])):
compas_rhino.rs.AddInterpCrvOnSrfUV(srf_guid,
[pt[:2] for pt in polyline])
for polyline in polylines
}
vkey_map = {
geometric_key(coarse_mesh.vertex_coordinates(vkey)): vkey
for vkey in coarse_mesh.vertices()
}
edges_to_curves = {
tuple([vkey_map[gkey] for gkey in geom_key]): curve
for geom_key, curve in nurbs_curves.items()
}
for edge, curve in edges_to_curves.items():
polyline = [
compas_rhino.rs.EvaluateCurve(
curve,
compas_rhino.rs.CurveParameter(curve,
float(t) / 99.0))
for t in range(100)
]
edges_to_curves[edge] = polyline
coarse_mesh.collect_strips()
coarse_mesh.set_strips_density_target(mesh_edge_length)
coarse_mesh.densification(edges_to_curves=edges_to_curves)
compas_rhino.rs.DeleteObjects(list(nurbs_curves.values()))
dense_mesh = coarse_mesh.get_quad_mesh()
vertices, faces = dense_mesh.to_vertices_and_faces()
return cls.from_vertices_and_faces(vertices.values(), faces.values())