WIP Rhino user interface without joinery.

Author: petrasvestartas

docs/examples/binding_read_xml_polylines_and_properties.py

@@ -22,7 +22,9 @@
     input_adjacency,
 ) = read_xml_polylines_and_properties(foldername, filename)
 
-print("vectors_lists:", vectors_lists)
+
+# print("polylines:", polylines)
+print("input_three_valence_element_indices_and_instruction:", input_three_valence_element_indices_and_instruction)
 print(filename)
 
 try:

src/rhino/plugin/commands/w_element_axis.py

@@ -2,54 +2,35 @@
 # venv: timber_connections
 
 import Rhino
+import Rhino.Input
+import Rhino.DocObjects
+from typing import *
+from wood_rui import wood_rui_globals, generalized_input_method, Element, add_sub_layer
 import System
 
-from wood_rui import (
-    select_and_find_valid_groups, polyline_obj_to_plane, generalized_input_method, add_sub_layer
-)
+def my_callback(input_dict, dataset_name):
 
-def string_to_xyz(s):
-    nums = list(map(float, s.split(',')))
-    points = [Rhino.Geometry.Point3d(nums[i], nums[i+1], nums[i+2]) for i in range(0, len(nums), 3)]
-    return points
+    if not input_dict["elements"]:
+        return
+    
+    elements : list[Element] = input_dict["elements"]
 
-def get_features(geometry_planes):
-
-    for geometry_plane in geometry_planes:
-
-        # Collect information from user strings
-        string_dictionary = geometry_plane[0].Attributes.GetUserStrings()
-        T = Rhino.Geometry.Transform.PlaneToPlane(Rhino.Geometry.Plane.WorldXY, polyline_obj_to_plane(geometry_plane[1]))
-
-        for key in string_dictionary:
-
-            if "axis" in key:
-                # Get axis and plane
-                value = string_dictionary[key]  # GetValues returns a list of values for the key
-                points = string_to_xyz(value)
-                axis = Rhino.Geometry.Polyline(points).ToNurbsCurve()
-                axis.Transform(T)
-                add_sub_layer(geometry_plane[0], "axis", [axis], [System.Drawing.Color.FromArgb(0,0,255)], False)
-
-
-        # Redraw the document to reflect changes
-        Rhino.RhinoDoc.ActiveDoc.Views.Redraw()
-
-def remove_features():
-    pass
-
-def add_features():
-    pass
-
-def update_features():
-    pass
+    for idx, element in enumerate(elements):
+        axes = element.axes
+        axes_curves = []
+        for axis in axes:
+            axes_curves.append(axis.ToNurbsCurve())
+        add_sub_layer(element.geometry_plane[0], "axes", axes_curves, [System.Drawing.Color.Red], idx==0)
+        
 
 if __name__ == "__main__":
-    geometry_planes = select_and_find_valid_groups("Elements")
-
-
-
 
-    get_features(geometry_planes)
+    dataset_name = "beam"
+    wood_rui_globals.init_data(dataset_name)
 
+    input_dict = {
+        "elements" : ([], List[Element]),
+    }
 
+   # Call the generalized input method with the dataset name and input dictionary
+    generalized_input_method(dataset_name, input_dict, my_callback, False, True)

src/rhino/plugin/commands/w_element_boolean.py

@@ -0,0 +1,164 @@
+#! python3
+# venv: timber_connections
+
+import Rhino
+import Rhino.Input
+import Rhino.DocObjects
+from typing import *
+from wood_rui import wood_rui_globals, generalized_input_method, Element, add_sub_layer
+import System
+
+def my_callback(input_dict, dataset_name):
+
+    if not input_dict["elements"]:
+        return
+    
+    elements : list[Element] = input_dict["elements"]
+
+    for idx, element in enumerate(elements):
+        element.boolean_difference()
+        # add_sub_layer(element.geometry_plane[0], "plane", plane_axes, [System.Drawing.Color.Red, System.Drawing.Color.Green, System.Drawing.Color.Blue], idx==0)
+        
+
+if __name__ == "__main__":
+
+    dataset_name = "beam"
+    wood_rui_globals.init_data(dataset_name)
+
+    input_dict = {
+        "elements" : ([], List[Element]),
+    }
+
+   # Call the generalized input method with the dataset name and input dictionary
+    generalized_input_method(dataset_name, input_dict, my_callback, False, True)
+
+# import Rhino
+# import System
+
+# from wood_rui import (
+#     select_and_find_valid_groups, polyline_obj_to_plane
+# )
+
+
+# def prepare_for_boolean_difference(geometry_planes):
+#     shapes = []
+#     cuts = []
+
+#     for geometry_plane in geometry_planes:
+#         obj = geometry_plane[0]
+#         geometry = obj.Geometry
+#         string_dictionary = obj.Attributes.GetUserStrings()
+
+#         T = Rhino.Geometry.Transform.PlaneToPlane(Rhino.Geometry.Plane.WorldXY, polyline_obj_to_plane(geometry_plane[1]))
+#         shapes.append(geometry)
+
+#         # Determine type-specific processing
+#         obj_type = type(geometry)
+#         valid_types = {
+#             Rhino.Geometry.Brep: Rhino.DocObjects.ObjectType.Brep,
+#             Rhino.Geometry.Mesh: Rhino.DocObjects.ObjectType.Mesh
+#         }
+
+#         if obj_type in valid_types:
+#             cut_list = []
+#             expected_type = valid_types[obj_type]
+
+#             for key in string_dictionary:
+#                 value = string_dictionary[key]
+#                 if "feature" in key:
+#                     feature_geometry = Rhino.Geometry.GeometryBase.FromJSON(value)
+#                     feature_geometry.Transform(T)
+#                     if feature_geometry.ObjectType == expected_type:
+#                         cut_list.append(feature_geometry)
+
+#             cuts.append(cut_list)
+
+#         # Redraw the document to reflect changes
+#         Rhino.RhinoDoc.ActiveDoc.Views.Redraw()
+
+#     return shapes, cuts
+
+# def clean_brep(brep : Rhino.Geometry.Brep):
+#     copy = brep.DuplicateBrep()
+#     copy.Faces.SplitKinkyFaces()
+#     if Rhino.Geometry.BrepSolidOrientation.Inward == copy.SolidOrientation:
+#         copy.Flip()
+#     return copy
+
+# def clean_mesh(mesh : Rhino.Geometry.Mesh):
+#     copy = mesh.DuplicateMesh()
+#     copy.Compact();
+#     copy.Vertices.CombineIdentical(True, True);
+#     copy.Vertices.CullUnused();
+#     copy.UnifyNormals();
+#     copy.Weld(3.14159265358979);
+#     copy.FaceNormals.ComputeFaceNormals();
+#     copy.Normals.ComputeNormals();
+#     if (copy.SolidOrientation() == -1):
+#         copy.Flip(True, True, True);
+#     return copy
+
+# def brep_boolean_difference(shape : Rhino.Geometry.Brep, cutters : list[Rhino.Geometry.Brep]):
+
+#     for i in range(len(shapes)):
+
+#         shape_cleaned = clean_brep(shape)
+
+#         for brep in cutters:
+#             cutter_cleaned = clean_brep(brep)
+#             out_breps = Rhino.Geometry.Brep.CreateBooleanDifference(shape_cleaned, cutter_cleaned, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance)
+            
+#             volume = 0
+            
+#             if out_breps:
+#                 for o in out_breps:
+#                     o_cleaned = clean_brep(o)
+#                     current_volume = Rhino.Geometry.VolumeMassProperties.Compute(o_cleaned, True, False, False, False).Volume;
+#                     if current_volume > volume:
+#                         volume = current_volume
+#                         shape_cleaned = o_cleaned
+
+#     return shape_cleaned
+
+# def mesh_boolean_difference(shape : Rhino.Geometry.Mesh, cutters : list[Rhino.Geometry.Mesh]):
+#     print(shape, cutters)
+#     for i in range(len(shapes)):
+
+#         shape_cleaned = clean_mesh(shape)
+
+#         for mesh in cutters:
+
+#             cutter_cleaned = clean_mesh(mesh)
+#             out_meshes = Rhino.Geometry.Mesh.CreateBooleanDifference([shape_cleaned], [cutter_cleaned])
+            
+#             volume = 0
+            
+#             if out_meshes:
+#                 for o in out_meshes:
+#                     o_cleaned = clean_mesh(o)
+#                     current_volume = Rhino.Geometry.VolumeMassProperties.Compute(o_cleaned, True, False, False, False).Volume;
+#                     if current_volume > volume:
+#                         volume = current_volume
+#                         shape_cleaned = o_cleaned
+
+#     return shape_cleaned
+
+# def boolean_difference(shapes : list[Rhino.Geometry.GeometryBase], cuts : list[list[Rhino.Geometry.GeometryBase]]):
+
+#     for i in range(len(shapes)):
+#         if isinstance(shapes[i], Rhino.Geometry.Brep):
+#             shapes[i] = brep_boolean_difference(shapes[i], cuts[i])
+#             Rhino.RhinoDoc.ActiveDoc.Objects.AddBrep(shapes[i])
+#         elif isinstance(shapes[i], Rhino.Geometry.Mesh):
+#             shapes[i] = mesh_boolean_difference(shapes[i], cuts[i])
+#             Rhino.RhinoDoc.ActiveDoc.Objects.AddMesh(shapes[i])
+            
+    
+
+
+# if __name__ == "__main__":
+#     geometry_planes = select_and_find_valid_groups("Elements")
+#     shapes, cuts = prepare_for_boolean_difference(geometry_planes)
+#     boolean_difference(shapes, cuts)
+
+