pattern templates

Author: tomvanmele

commands/RV_pattern.py

@@ -3,17 +3,18 @@
 # r: compas_rv>=0.9.1
 
 import rhinoscriptsyntax as rs  # type: ignore
-from compas_skeleton.datastructures import Skeleton
-from compas_triangle.delaunay import conforming_delaunay_triangulation
-from compas_triangle.rhino import discretise_boundary
-from compas_triangle.rhino import discretise_constraints
-
-import compas_rhino
-import compas_rhino.conversions
-import compas_rhino.objects
-from compas.geometry import NurbsCurve
-from compas.geometry import Point
-from compas_rv.datastructures import Pattern
+
+from compas_rv.commands import make_pattern_from_meshgrid
+from compas_rv.commands import make_pattern_from_rhinolines
+from compas_rv.commands import make_pattern_from_rhinomesh
+from compas_rv.commands import make_pattern_from_rhinosurface
+from compas_rv.commands import make_pattern_from_skeleton
+from compas_rv.commands import make_pattern_from_triangulation
+from compas_rv.patterns.circular import create_circular_radial_pattern
+from compas_rv.patterns.circular import create_circular_radial_spaced_pattern
+from compas_rv.patterns.circular import create_circular_spiral_pattern
+from compas_rv.patterns.rectangular import create_cross_pattern
+from compas_rv.patterns.rectangular import create_fan_pattern
 from compas_rv.session import RVSession
 
 
@@ -47,151 +48,61 @@ def RunCommand():
             "MeshGrid",
             "Triangulation",
             "Skeleton",
+            "Json",
+            "Template",
         ],
     )
 
     if option == "RhinoLines":
-        guids = compas_rhino.objects.select_lines("Select lines")
-        if not guids:
-            return
-
-        lines = compas_rhino.objects.get_line_coordinates(guids)
-        if not lines:
-            return
-
-        pattern = Pattern.from_lines(lines, delete_boundary_face=True)
-
-        rs.HideObjects(guids)
+        pattern = make_pattern_from_rhinolines()
 
     elif option == "RhinoMesh":
-        guid = compas_rhino.objects.select_mesh("Select a mesh")
-        if not guid:
-            return
-
-        obj = compas_rhino.objects.find_object(guid)
-        pattern = compas_rhino.conversions.mesh_to_compas(obj.Geometry, cls=Pattern)
-
-        rs.HideObject(guid)
+        pattern = make_pattern_from_rhinomesh()
 
     elif option == "RhinoSurface":
-        guid = compas_rhino.objects.select_surface("Select a surface")
-        if not guid:
-            return
-
-        U = rs.GetInteger(message="U faces", number=16, minimum=2, maximum=64)
-        if not U:
-            return
-
-        V = rs.GetInteger(message="V faces", number=4, minimum=2, maximum=64)
-        if not V:
-            return
-
-        # ------------------------------------------------
-
-        obj = compas_rhino.objects.find_object(guid)
-        brep = obj.Geometry
-        surface = brep.Surfaces[0]
-
-        # ------------------------------------------------
-
-        pattern = compas_rhino.conversions.surface_to_compas_mesh(surface, nu=U, nv=V, weld=True, cls=Pattern)
-
-        rs.HideObject(guid)
+        pattern = make_pattern_from_rhinosurface()
 
     elif option == "MeshGrid":
-        DX = rs.GetInteger(message="X Size", number=10)
-        if not DX:
-            return
-
-        DY = rs.GetInteger(message="Y Size", number=DX)
-        if not DY:
-            return
-
-        NX = rs.GetInteger(message="Number of faces in X", number=10)
-        if not NX:
-            return
-
-        NY = rs.GetInteger(message="Number of faces in Y", number=NX)
-        if not NY:
-            return
-
-        pattern = Pattern.from_meshgrid(dx=DX, nx=NX, dy=DY, ny=NY)
+        pattern = make_pattern_from_meshgrid()
 
     elif option == "Triangulation":
-        boundary_guids = compas_rhino.objects.select_curves("Select outer boundary.")
-        if not boundary_guids:
-            return
-
-        rs.UnselectAllObjects()
-        hole_guids = compas_rhino.objects.select_curves("Select inner boundaries.")
-
-        rs.UnselectAllObjects()
-        segments_guids = compas_rhino.objects.select_curves("Select constraint curves.")
-
-        rs.UnselectAllObjects()
-
-        target_length = rs.GetReal("Specifiy target edge length.", 1.0)
-        if not target_length:
-            return
-
-        boundary = discretise_boundary(boundary_guids, target_length)
-        holes = None
-        segments = None
-        curves = None
-
-        if hole_guids:
-            holes = discretise_constraints(hole_guids, target_length)
-
-        if segments_guids:
-            segments = discretise_constraints(segments_guids, target_length)
-            curves: list[NurbsCurve] = [NurbsCurve.from_interpolation(segment) for segment in segments]
-
-        points, triangles = conforming_delaunay_triangulation(
-            boundary,
-            polylines=segments,
-            polygons=holes,
-            area=target_length**2 / 2,
-        )
-        pattern = Pattern.from_vertices_and_faces(points, triangles)
-
-        fixed = [vertex for boundary in pattern.vertices_on_boundaries() for vertex in boundary]
-        if curves:
-            for index, point in enumerate(points):
-                for curve in curves:
-                    closest: Point = curve.closest_point(point)
-                    if closest.distance_to_point(point) < 0.1 * target_length:
-                        fixed.append(index)
-
-        pattern.smooth_area(fixed=fixed)
+        pattern = make_pattern_from_triangulation()
 
     elif option == "Skeleton":
-        guids = compas_rhino.objects.select_lines("Select skeleton lines.")
-        if not guids:
-            return
+        pattern = make_pattern_from_skeleton()
+
+    elif option == "Json":
+        raise NotImplementedError
+
+    elif option == "Template":
+        option2 = rs.GetString(
+            message="Template Name",
+            strings=[
+                "Radial",
+                "RadialSpaced",
+                "Spiral",
+                "Cross",
+                "Fan",
+            ],
+        )
 
-        rs.UnselectAllObjects()
+        if option2 == "Radial":
+            pattern = create_circular_radial_pattern()
 
-        width = rs.GetReal("Specifiy skeleton width.", 1.0)
-        if not width:
-            return
+        elif option2 == "RadialSpaced":
+            pattern = create_circular_radial_spaced_pattern()
 
-        angle = rs.GetReal("Specifiy skeleton leaf angle (degrees).", 30)
-        if not angle:
-            return
+        elif option2 == "Spiral":
+            pattern = create_circular_spiral_pattern()
 
-        density = rs.GetInteger("Specifiy skeleton density.", 2)
-        if not density:
-            return
+        elif option2 == "Cross":
+            pattern = create_cross_pattern()
 
-        objects = [compas_rhino.objects.find_object(guid) for guid in guids]
-        curves = [obj.Geometry for obj in objects]
-        lines = [compas_rhino.conversions.curve_to_compas_line(curve) for curve in curves]
+        elif option2 == "Fan":
+            pattern = create_fan_pattern()
 
-        skeleton = Skeleton(lines)
-        skeleton.node_width = width
-        skeleton.leaf_angle = angle
-        skeleton.density = density
-        pattern = skeleton.pattern.copy(cls=Pattern)
+        else:
+            raise NotImplementedError
 
     else:
         return
@@ -200,7 +111,7 @@ def RunCommand():
     # Update scene
     # =============================================================================
 
-    session.scene.add(pattern, name=pattern.name)
+    session.scene.add(pattern, name=pattern.name)  # type: ignore
     session.scene.draw()
 
     print("Pattern successfully created.")