ADD custom joints.

Author: petrasvestartas

src/rhino/raw/commands/w_raw_axis.py

@@ -8,7 +8,6 @@
 from System.Drawing import Color
 
 
-
 def callback(selection: dict[str, any], name: str):
     if not selection["elements"]:
         return

src/rhino/raw/commands/w_raw_custom_joints.py

@@ -0,0 +1,73 @@
+#! python3
+# venv: timber_connections
+
+import Rhino
+from wood_rui import process_input
+from wood_rui import add_sub_layer
+from wood_rui import Element
+from System.Drawing import Color
+from compas_wood.binding import wood_globals
+
+def duplicate(data : list[Rhino.Geometry.Polyline]):
+    duplicated_data = []
+    for d in data:
+        if d.Count == 2:
+            duplicated_data.append(d)
+            duplicated_data.append(d)
+        else:
+            duplicated_data.append(d)
+
+    return(duplicated_data)
+
+
+
+def callback(selection: dict[str, any], name: str):
+
+    for key, item in selection.items():
+        
+        key_to_attr = {
+            "ss_e_ip_positive": "custom_joints_ss_e_ip_male",
+            "ss_e_ip_negative": "custom_joints_ss_e_ip_female",
+            "ss_e_op_positive": "custom_joints_ss_e_op_male",
+            "ss_e_op_negative": "custom_joints_ss_e_op_female",
+            "ts_e_p_positive": "custom_joints_ts_e_p_male",
+            "ts_e_p_negative": "custom_joints_ts_e_p_female",
+            "cr_c_ip_positive": "custom_joints_cr_c_ip_male",
+            "cr_c_ip_negative": "custom_joints_cr_c_ip_female",
+            "tt_e_p_positive": "custom_joints_tt_e_p_male",
+            "tt_e_p_negative": "custom_joints_tt_e_p_female",
+            "ss_e_r_positive": "custom_joints_ss_e_r_male",
+            "ss_e_r_negative": "custom_joints_ss_e_r_female",
+            "b_positive": "custom_joints_b_male",
+            "b_negative": "custom_joints_b_female",
+        }
+
+        for key, item in selection.items():
+            if key in key_to_attr:
+                attr_name = key_to_attr[key]
+                duplicated_item = duplicate(item)
+                setattr(wood_globals, attr_name, duplicated_item)
+                print(f"{attr_name}: {duplicated_item}")
+
+    return
+
+
+if __name__ == "__main__":
+    selection_types: dict[str, tuple] = {
+        "ss_e_ip_positive": ([], list[Rhino.Geometry.Polyline]),
+        "ss_e_ip_negative": ([], list[Rhino.Geometry.Polyline]),
+        "ss_e_op_positive": ([], list[Rhino.Geometry.Polyline]),
+        "ss_e_op_negative": ([], list[Rhino.Geometry.Polyline]),
+        "ts_e_p_positive": ([], list[Rhino.Geometry.Polyline]),
+        "ts_e_p_negative": ([], list[Rhino.Geometry.Polyline]),
+        "cr_c_ip_positive": ([], list[Rhino.Geometry.Polyline]),
+        "cr_c_ip_negative": ([], list[Rhino.Geometry.Polyline]),
+        "tt_e_p_positive": ([], list[Rhino.Geometry.Polyline]),
+        "tt_e_p_negative": ([], list[Rhino.Geometry.Polyline]),
+        "ss_e_r_positive": ([], list[Rhino.Geometry.Polyline]),
+        "ss_e_r_negative": ([], list[Rhino.Geometry.Polyline]),
+        "b_positive": ([], list[Rhino.Geometry.Polyline]),
+        "b_negative": ([], list[Rhino.Geometry.Polyline]),
+    }
+
+    process_input(selection_types, callback)

src/rhino/raw/commands/w_raw_features.py

@@ -35,6 +35,7 @@ def callback(selection: dict[str, any], name: str):
 
     return
 
+
 if __name__ == "__main__":
     selection_types: dict[str, tuple] = {
         "element": ([], list[Element]),

src/rhino/raw/commands/w_raw_features_parallel.py

@@ -1,127 +1,99 @@
 #! python3
 # venv: timber_connections
 
-# TODO:
-
-# Parallel Features
-# Check Compas_wood project considering changes to compas_rui
-
-# Publish raw to YAK
-# Publish wood_nano, wood_rui to PyPi
-# Publish compas_wood to YAK
-
-# Custom Joints
-# Check How to input varying axis
-
-
-import Rhino
-from wood_rui import process_input
-from wood_rui import Element
-from wood_rui import add_sub_layer
-from System.Drawing import Color
-
-#! python3
-# venv: timber_connections
-
 import Rhino
 from wood_rui import process_input
 from wood_rui import Element
 from wood_rui import add_sub_layer
 from System.Drawing import Color
 
-
-
-def closest_curves(
-    curves: list[Rhino.Geometry.NurbsCurve],
-    radii : list[float],
-    distance : float,
-    display_closest_line_segments : bool
-) -> None:
-
-
-    ###############################################################################
-    # Run the closest point search
-    ###############################################################################
-    bboxes = []
-    for idx, c in enumerate(curves):
-        bbox : Rhino.Geometry.BoundingBox = c.GetBoundingBox(True)
-        bbox.Inflate(radii[idx] + 0.02)
-        bboxes.append(bbox)
-
-
-    # create a tree
-    rtree = Rhino.Geometry.RTree()
-
-    # fill the tree
-    for idx, bbox in enumerate(bboxes):
-        rtree.Insert(bbox, idx)
-
-    # call_backs of rtree
-    def search_callback(sender, rtree_event_args):
-        data_by_reference.append(rtree_event_args.Id)
-
-    neighbours : list[list[int, int]] = []
-
-    # perform search
-    for i in range(len(bboxes)):
-        data_by_reference = []
-        if rtree.Search(
-            bboxes[i], search_callback, data_by_reference
-        ):
-            for j in data_by_reference:
-                if j < i:
-                    continue
-                result, p0, p1 = curves[i].ClosestPoints(curves[j])
-
-                if(distance < p0.DistanceTo(p1)):
-                    neighbours.append([i, j])
-                    if display_closest_line_segments:
-                        line = Rhino.Geometry.Line(p0, p1)
-                        Rhino.RhinoDoc.ActiveDoc.Objects.AddLine(line)
-                    
-
-    print(neighbours)
-
-    ###############################################################################
-    # Output
-    ###############################################################################
-    return
-
-
-
 def callback(selection: dict[str, any], name: str):
+
     if not selection["elements"]:
         return
-    
-    # Extract axes and radii
-    curves = []
-    radii = []
-    for idx, element in enumerate(selection["elements"]):
-        curves.append(element.axes[0].ToNurbsCurve())
-        radii.append(max(element.radii[0]))
-
-    # Run closest curve search 
-    closest_curves(curves, radii, 25)
-
-
 
-
-
-        # add_sub_layer(
-        #     element.geometry_plane[0],
-        #     "axes",
-        #     axes_curves,
-        #     [Color.FromArgb(255, 30, 144, 255)],
-        #     idx == 0,
-        #     True,
-        # )
+    # Run closest curve search
+    neighbours, planes, lines = Element.closest_axis(
+        selection["elements"],
+        selection["distance"],
+        selection["display_plane"],
+        selection["display_line"],
+    )
+
+    ####################################################################################################
+    # Collect Neighbour Information
+    ####################################################################################################
+    neighbours_for_user_data = {}
+    features = {}
+
+    # Explicit loop for initialization
+    for idx in range(len(selection["elements"])):
+        neighbours_for_user_data[idx] = []
+        features[idx] = []
+
+    # Populate neighbour relationships
+    for pair in neighbours:
+        a, b = pair  # Explicit unpacking for clarity
+        neighbours_for_user_data[a].append(b)
+        neighbours_for_user_data[b].append(a)
+
+    # Assign indices and sorted neighbours
+    for idx, element in enumerate(selection["elements"]):
+        element.index = idx
+        element.neighbours = sorted(neighbours_for_user_data[idx])
+
+    ####################################################################################################
+    # Collect breps into the features dictionary
+    ####################################################################################################
+    for pair, target_plane in zip(neighbours, planes):
+        element_pair = [selection["elements"][pair[0]], selection["elements"][pair[1]]]
+        breps_pair = [selection["features_positive"], selection["features_negative"]]
+
+        T = Rhino.Geometry.Transform.PlaneToPlane(
+            Rhino.Geometry.Plane.WorldXY, target_plane
+        )
+
+        for element, breps in zip(element_pair, breps_pair):
+            breps_copies = []
+            for brep in breps:
+                breps_copies.append(brep.DuplicateBrep())
+                breps_copies[-1].Transform(T)
+            features[element.index].extend(breps_copies)
+
+    ####################################################################################################
+    # Assign features to the elements
+    ####################################################################################################
+    for idx, element in enumerate(selection["elements"]):
+        new_features = (
+            features[element.index]
+            if selection["replace_or_extend_features"]
+            else features[element.index] + element.features
+        )
+
+        # Display must be in this position, because setter of features transforms BReps
+        if selection["display_features"]:
+            add_sub_layer(
+                element.geometry_plane[0],
+                "features",
+                new_features,
+                [Color.FromArgb(0, 0, 255)],
+                idx == 0,
+                True,
+            )
+
+        element.features = new_features
 
 
 if __name__ == "__main__":
     selection_types: dict[str, tuple] = {
         "elements": ([], list[Element]),
-        "features": ([], list[Rhino.Geometry.Brep]),
+        "features_positive": ([], list[Rhino.Geometry.Brep]),
+        "features_negative": ([], list[Rhino.Geometry.Brep]),
+        "distance": (150, float),
+        "display_plane": (False, bool),
+        "display_line": (False, bool),
+        "display_features": (False, bool),
+        "replace_or_extend_features": (True, bool),
     }
 
-    process_input(selection_types, callback)
-
+    process_input(selection_types, callback, hide_input=False)

src/rhino/raw/commands/w_raw_find_volumes.py

@@ -225,15 +225,15 @@ def from_point3(point3):
 
 if __name__ == "__main__":
     selection_types: dict[str, tuple] = {
-        "elements": ([], List[Element]),
+        "elements": ([], list[Element]),
         "allowed_types_per_polyline": (
             [-1],
-            List[int],
+            list[int],
         ),  # Default value for types (list of ints)
         "min_distance": (100, float),  # Default value for min distance (float)
         "volume_length": (500, float),  # Default value for volume length (float)
         "cross_or_side_to_end": (
-            0.91,
+            0.75,
             float,
         ),  # Default value for cross or side to end (float)
         "find_insertion": (

src/rhino/raw/commands/w_raw_shape.py

@@ -17,7 +17,7 @@ def callback(selection: dict[str, any], name: str):
 
     for idx, element in enumerate(selection["elements"]):
         element.shape = selection["shape"][idx % num_shapes]  # Cycle through shapes
-    
+
     return
 
 

src/rhino/raw/commands/w_raw_skeleton.py

@@ -11,7 +11,6 @@
 
 
 def callback(selection: dict[str, any], name: str):
-
     # Just axis without radii
     if not selection["simplify"]:
         for mesh in selection["meshes"]:
@@ -20,15 +19,14 @@ def callback(selection: dict[str, any], name: str):
                 Rhino.RhinoDoc.ActiveDoc.Objects.AddPolyline(polyline)
         return
 
-    # Try to simplify an axis 
+    # Try to simplify an axis
 
     polylines = []
     distances = []
     meshes = []
     transforms = []
 
     for mesh in selection["meshes"]:
-
         polyline = None
         polylines = []
 
@@ -60,11 +58,9 @@ def callback(selection: dict[str, any], name: str):
 
 
 if __name__ == "__main__":
-
-
     input_dict = {
         "meshes": ([], list[Rhino.Geometry.Mesh]),
-        "simplify" : (False, bool),
+        "simplify": (False, bool),
         "divisions": (10, int),
         "nearest_neighbors": (10, int),
         "extend_end": (True, bool),

src/rhino/raw/commands/w_raw_solver.py

@@ -190,14 +190,6 @@ def callback(selection: dict[str, any], name: str):
     ir_joint_volume_extension = wood_rui_globals.joint_volume_extension
     iw_joint_volume_extension = to_double1(ir_joint_volume_extension)
 
-    ######################################################################
-    # input_custom_joints
-    ######################################################################
-
-    ######################################################################
-    # input_custom_joints_types
-    ######################################################################
-
     ######################################################################
     # output
     ######################################################################
@@ -244,15 +236,19 @@ def callback(selection: dict[str, any], name: str):
                 polyline1 = polylines[j + 1]
                 fab_type = types[int(j * 0.5)]
 
-                if fab_type != "drill" and wood_rui_globals.dowel_radius > 0.01:
+                print(polyline0.Count)
+                print(polyline1.Count)
+                print(fab_type)
+
+                if fab_type != "drill" and polyline0.Count != 2:
                     brep = Element.loft_polylines_with_holes(
                         [polyline0.ToNurbsCurve()],
                         [polyline1.ToNurbsCurve()],
                         System.Drawing.Color.Red,
                     )
                     # Rhino.RhinoDoc.ActiveDoc.Objects.AddBrep(brep)
                     grouped_breps[index_to_group[count][0]].append(brep)
-                else:
+                elif wood_rui_globals.dowel_radius > 0.01:
                     plane = Rhino.Geometry.Plane(
                         polyline0[0], polyline0.SegmentAt(0).Direction
                     )