WIP RhinoUI split between plates and beams

Author: petrasvestartas

docs/examples/binding_get_connection_zones_beams.py

@@ -1,14 +1,14 @@
 from compas_wood.binding import get_connection_zones
-from compas.geometry import Polyline
+from compas.geometry import Polyline, Point, Rotation, Frame
 from compas_wood import data_sets_plates
-
+import math
 
 # joinery parameters
 division_length = 300
 joint_parameters = [
     100,
     0.5,
-    5,
+    4,
     division_length * 1.5,
     0.65,
     10,
@@ -57,6 +57,16 @@
     ])
 ]
 
+
+# Rotate polyline 180 degrees to check if it has any influence on the results
+point = Point(37, 79, 0)
+axis = [1, 0, 0]
+angle = math.pi
+T = Rotation.from_axis_and_angle(axis, angle, point)
+polylines[2].transform(T)
+polylines[3].transform(T)
+
+
 # generate joints
 polylines_lists, output_types, new_polyline_lists = get_connection_zones(
     polylines,
@@ -67,7 +77,7 @@
     joint_parameters,
     0,
     [1, 1, 1],
-    3,
+    2,
 )
 
 
@@ -82,7 +92,13 @@
     for polylines in polylines_lists:
         for polyline in polylines:
             polyline.transform(scale_transform)
-            viewer.scene.add(Polyline(polyline), show_points=False)
+            viewer.scene.add(polyline, show_points=False)
+            viewer.scene.add(polyline[0])
+    
+    viewer.scene.add(point.transformed(scale_transform)) 
+
+
+    viewer.scene.add(polylines)
 
     viewer.show()
 

src/rhino/plugin/commands/w_dataset.py

@@ -1,11 +1,12 @@
+# flags: python.reloadEngine
 #! python3
 # venv: timber_connections
 import Rhino
 import System
 import System.IO
 from compas_wood.binding import read_xml_polylines
 import os
-from wood_rui import add_polylines, wood_rui_globals, BooleanForm, generalized_input_method
+from wood_rui import add_polylines_dataset, wood_rui_globals, BooleanForm, process_input
 from wood_nano import read_xml_polylines as wood_nano_read_xml_polylines
 from wood_nano import double2
 from typing import *
@@ -83,28 +84,29 @@ def load_data_set():  # path: str = "C://brg//2_code//compas_wood//src//rhino//p
             wood_rui_globals.init_data(value[0])
             polylines = read_xml_polylines(foldername, value[0])
             wood_rui_globals[value[0]]["polylines"] = polylines
-            add_polylines(polylines, value[0])
+            add_polylines_dataset(polylines, value[0])
             Rhino.RhinoDoc.ActiveDoc.Views.ActiveView.Redraw()  # 0 ms
 
     return file_names_without_extensions
 
 
-def my_callback(name_value_type, dataset_name):
+def callback(selection: dict[str, any], dataset_name: str):
 
-    if len(input_dict["polylines"][0]) > 0:
+    if len(selection["polylines"]) > 0:
         dataset_name = "default"
         wood_rui_globals.init_data(dataset_name)
-        add_polylines(input_dict["polylines"][0], dataset_name)
+        add_polylines_dataset(selection["polylines"], dataset_name)
 
 
 if __name__ == "__main__":
 
+    dataset_name = "default"
+
     # Define the input dictionary based on your initial dataset
-    input_dict = {
-        "library": (load_data_set, Callable),  # Default value for weld radius (float)
-        "polylines": ([], List[Rhino.Geometry.Polyline]),  # Default value for polylines (list of polylines)
+    selection_types = {
+        "selection_types": (load_data_set, Callable),  # Default value for weld radius (float)
+        "polylines": ([], list[Rhino.Geometry.Polyline]),  # Default value for polylines (list of polylines)
     }
 
     # Call the generalized input method with the dataset name and input dictionary
-    dataset_name = "default"
-    generalized_input_method(dataset_name, input_dict, my_callback)
+    process_input(selection_types, callback, dataset_name = dataset_name)

src/rhino/plugin/commands/w_dataset_annen.py

@@ -1,10 +1,11 @@
+# flags: python.reloadEngine
 #! python3
 # venv: timber_connections
 import Rhino
 from wood_rui import (
     wood_rui_globals,
     ensure_layer_exists,
-    add_polylines,
+    add_polylines_dataset,
     add_mesh,
     add_adjacency,
     add_insertion_vectors,
@@ -750,7 +751,7 @@ def run(self, dataset_name):
         self.get_plates()
         self.get_joinery_solver_output()
 
-        add_polylines(self.plines, dataset_name)
+        add_polylines_dataset(self.plines, dataset_name)
         add_insertion_vectors(self.insertion_vectors, dataset_name)
         add_joint_type(self.joints_per_face, dataset_name)
         add_three_valence(self.three_valence, dataset_name)

src/rhino/plugin/commands/w_dataset_beam_volume.py

@@ -1,3 +1,4 @@
+# flags: python.reloadEngine
 #! python3
 # venv: timber_connections
 from wood_nano import beam_volumes as wood_nano_beam_volumes

src/rhino/plugin/commands/w_dataset_closest_lines_insertion.py

@@ -1,3 +1,4 @@
+# flags: python.reloadEngine
 #! python3
 # venv: timber_connections
 import Rhino
@@ -7,7 +8,7 @@
 from wood_rui import wood_rui_globals, get_objects_by_layer
 
 
-def closest_lines(dataset_name: str, lines: List[Rhino.Geometry.Line]) -> None:
+def closest_lines(dataset_name: str, lines: List[Rhino.Geometry.Line], tolerance) -> None:
     """
     Match the closest lines from the selected dataset to the input lines and update
     the insertion vectors.
@@ -43,7 +44,7 @@ def closest_lines(dataset_name: str, lines: List[Rhino.Geometry.Line]) -> None:
         for j in range(len(polylines[i])):
             for k in range(polylines[i][j].SegmentCount):
                 bbox = polylines[i][j].SegmentAt(k).BoundingBox
-                bbox.Inflate(0.02)
+                bbox.Inflate(tolerance)
                 segments_dictionary[count] = [i, j, k, bbox, polylines[i][j].SegmentAt(k)]
                 count += 1
 
@@ -61,14 +62,14 @@ def search_callback(sender: Any, rtree_event_args: Rhino.Geometry.RTreeEventArgs
         data_by_reference: List[int] = []
         if rtree.Search(Rhino.Geometry.Sphere(lines[i].From, 0), search_callback, data_by_reference):
             for j in data_by_reference:
-                if lines[i].From.DistanceToSquared(segments_dictionary[j][4].ClosestPoint(lines[i].From, True)) < 0.001:
+                if lines[i].From.DistanceToSquared(segments_dictionary[j][4].ClosestPoint(lines[i].From, True)) < tolerance:
                     vectors[segments_dictionary[j][0]][segments_dictionary[j][2] + 2] = lines[i].Direction
 
     for i in range(len(lines)):
         data_by_reference: List[int] = []
         if rtree.Search(Rhino.Geometry.Sphere(lines[i].To, 0), search_callback, data_by_reference):
             for j in data_by_reference:
-                if lines[i].To.DistanceToSquared(segments_dictionary[j][4].ClosestPoint(lines[i].To, True)) < 0.001:
+                if lines[i].To.DistanceToSquared(segments_dictionary[j][4].ClosestPoint(lines[i].To, True)) < tolerance:
                     vectors[segments_dictionary[j][0]][segments_dictionary[j][2] + 2] = -lines[i].Direction
 
     # Store the insertion vectors in the global data structure
@@ -161,4 +162,4 @@ def command_line_input() -> Tuple[str, List[Rhino.Geometry.Line]]:
 if __name__ == "__main__":
     selected_case_name, selected_lines = command_line_input()
     if selected_case_name and selected_lines:
-        closest_lines(selected_case_name, selected_lines)
+        closest_lines(selected_case_name, selected_lines, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance*20)

src/rhino/plugin/commands/w_dataset_closest_points_joints.py

@@ -1,3 +1,4 @@
+# flags: python.reloadEngine
 #! python3
 # venv: timber_connections
 import Rhino
@@ -9,7 +10,7 @@
 import ast
 
 
-def closest_points(dataset_name: str, points: List[Rhino.Geometry.Point3d], points_ids: List[int]) -> None:
+def closest_points(dataset_name: str, points: List[Rhino.Geometry.Point3d], points_ids: List[int], tolerance) -> None:
     """component iterates polyline edges and assigns index based on the point list and their type RTree search
 
     Match the closest lines from the selected dataset to the input lines and update
@@ -50,7 +51,7 @@ def closest_points(dataset_name: str, points: List[Rhino.Geometry.Point3d], poin
         for j in range(len(polylines[i])):
             for k in range(polylines[i][j].SegmentCount):
                 bbox = polylines[i][j].SegmentAt(k).BoundingBox
-                bbox.Inflate(0.02)
+                bbox.Inflate(tolerance)
                 segments_dictionary[count] = [i, j, k, bbox, polylines[i][j].SegmentAt(k)]
                 count = count + 1
 
@@ -70,9 +71,10 @@ def search_callback(sender, rtree_event_args):
         data_by_reference = []
         if rtree.Search(Rhino.Geometry.Sphere(points[i], 0), search_callback, data_by_reference):
             for j in data_by_reference:
-                if points[i].DistanceToSquared(segments_dictionary[j][4].ClosestPoint(points[i], True)) < 0.001:
+                if points[i].DistanceToSquared(segments_dictionary[j][4].ClosestPoint(points[i], True)) < tolerance:
                     joint_types[segments_dictionary[j][0]][segments_dictionary[j][2] + 2] = points_ids[i]
 
+    print(joint_types)
     ###############################################################################
     # Output
     ###############################################################################
@@ -169,4 +171,4 @@ def command_line_input() -> Tuple[str, List[Rhino.Geometry.Point3d], List[int]]:
 
     selected_case_name, selected_points, selected_values = command_line_input()
     if selected_case_name and selected_points and selected_values:
-        closest_points(selected_case_name, selected_points, selected_values)
+        closest_points(selected_case_name, selected_points, selected_values, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance*20)