WIP-FIX: solved circular import problem

Author: 9and3

deps/eigen

@@ -1,5 +1,5 @@
 #! python3
-# requirements: diffCheck
+# r: diffCheck==0.0.8
 
 import System
 import typing
@@ -9,19 +9,16 @@
 
 from ghpythonlib.componentbase import executingcomponent as component
 
-from diffCheck.df_geometries import DFVertex, DFFace, DFBeam, DFAssembly
-import diffCheck.df_transformations
-import diffCheck.df_joint_detector
-import diffCheck.df_util
+import diffCheck
+from diffCheck.df_geometries import DFBeam, DFAssembly
 
 
 class DFXMLExporter(component):
     def RunScript(self,
-                  i_dump : bool,
-                  i_assembly_name : str,
-                  i_export_dir : str,
-                  i_breps : typing.List[Rhino.Geometry.Brep]
-                  ):
+            i_dump: bool,
+            i_assembly_name,
+            i_export_dir,
+            i_breps: System.Collections.Generic.IList[Rhino.Geometry.Brep]):
         """
             This read breps from Rhino, converts them to DFBeams and DFAssemblies, and exports them to XML.
             
@@ -30,7 +27,7 @@ def RunScript(self,
             :param i_breps: list of breps
         """
         # beams
-        beams : typing.List[DFBeam] = []
+        beams: typing.List[DFBeam] = []
         for brep in i_breps:
             beam = DFBeam.from_brep(brep)
             beams.append(beam)
@@ -39,9 +36,9 @@ def RunScript(self,
         assembly1 = DFAssembly(beams, i_assembly_name)
 
         # dump the xml
-        xml : str = assembly1.to_xml()
+        xml: str = assembly1.to_xml()
         if i_dump:
-            assembly1.dump(xml, i_export_dir)
+            assembly1.dump_xml(xml, i_export_dir)
         o_xml = xml
 
         # show the joint/side faces

examples/exporter.ghx

@@ -1 +1 @@
-__version__ = '0.0.3'
+__version__ = "0.0.8"

src/gh/components/DF_xml_exporter/code.py

@@ -18,9 +18,11 @@ class DFVertex:
     """
     This class represents a vertex, a simple container with 3 coordinates
     """
-    x : float
-    y : float
-    z : float
+
+    x: float
+    y: float
+    z: float
+
     def __post_init__(self):
         self.x = self.x or 0.0
         self.y = self.y or 0.0
@@ -61,46 +63,41 @@ class DFFace:
     """
     This class represents a face, in diffCheck, a face is a collection of vertices.
     """
+
     # just as breps a first outer loop and then inner loops of DFVertices
-    all_loops : typing.List[typing.List[DFVertex]]
-    joint_id : int
+    all_loops: typing.List[typing.List[DFVertex]]
+    joint_id: int = None
+
     def __post_init__(self):
         if len(self.all_loops[0]) < 3:
             raise ValueError("A face must have at least 3 vertices")
-        self.all_loops = self.all_loops or []
+        self.all_loops = self.all_loops
 
-        self.joint_id = self.joint_id or None
+        self.joint_id = self.joint_id
         self.__is_joint = False
         self.__id = uuid.uuid4().int
 
     def __repr__(self):
         return f"Face id: {len(self.id)}, IsJoint: {self.is_joint} Loops: {len(self.all_loops)}"
 
     def __hash__(self):
-        outer_loop = tuple(tuple(vertex.__dict__.values()) for vertex in self.all_loops[0])
-        inner_loops = tuple(tuple(vertex.__dict__.values()) for loop in self.all_loops[1:] for vertex in loop)
+        outer_loop = tuple(
+            tuple(vertex.__dict__.values()) for vertex in self.all_loops[0]
+        )
+        inner_loops = tuple(
+            tuple(vertex.__dict__.values())
+            for loop in self.all_loops[1:]
+            for vertex in loop
+        )
         return hash((outer_loop, inner_loops))
 
     def __eq__(self, other):
         if isinstance(other, DFFace):
             return self.all_loops == other.all_loops
         return False
 
-    @staticmethod
-    def compute_mass_center(face: rg.BrepFace) -> rg.Point3d:
-        """
-        Compute the mass center of a  face
-
-        :param face: The face to compute the mass center from
-        :return mass_center: The mass center of the face
-        """
-        amp = rg.AreaMassProperties.Compute(face)
-        if amp:
-            return amp.Centroid
-        return None
-
     @classmethod
-    def from_brep(cls, brep_face: rg.BrepFace, joint_id: int=None):
+    def from_brep(cls, brep_face: rg.BrepFace, joint_id: int = None):
         """
         Create a DFFace from a Rhino Brep face
 
@@ -135,12 +132,16 @@ def to_brep(self):
         brep_curves = []
 
         for loop in self.all_loops:
-            inner_vertices = [rg.Point3d(vertex.x, vertex.y, vertex.z) for vertex in loop]
+            inner_vertices = [
+                rg.Point3d(vertex.x, vertex.y, vertex.z) for vertex in loop
+            ]
             inner_polyline = rg.Polyline(inner_vertices)
             inner_curve = inner_polyline.ToNurbsCurve()
             brep_curves.append(inner_curve)
 
-        brep = rg.Brep.CreatePlanarBreps(brep_curves, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance)[0]
+        brep = rg.Brep.CreatePlanarBreps(
+            brep_curves, Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance
+        )[0]
 
         return brep
 
@@ -171,8 +172,10 @@ class DFBeam:
     """
     This class represents a beam, in diffCheck, a beam is a collection of faces
     """
-    name : str
-    faces : typing.List[DFFace]
+
+    name: str
+    faces: typing.List[DFFace]
+
     def __post_init__(self):
         self.name = self.name or "Unnamed Beam"
         self.faces = self.faces or []
@@ -187,8 +190,11 @@ def from_brep(cls, brep):
         Create a DFBeam from a RhinoBrep object.
         It also removes duplicates and creates a list of unique faces.
         """
-        faces = diffCheck.df_joint_detector.JointDetector(brep).run()
-        faces = list(set(faces))
+        faces : typing.List[DFFace] = []
+        data_faces = diffCheck.df_joint_detector.JointDetector(brep).run()
+        for data in data_faces:
+            face = DFFace.from_brep(data[0], data[1])
+            faces.append(face)
         beam = cls("Beam", faces)
         return beam
 
@@ -213,8 +219,10 @@ class DFAssembly:
     """
     This class represents an assembly of beams
     """
-    beams : typing.List[DFBeam]
-    name : str
+
+    beams: typing.List[DFBeam]
+    name: str
+
     def __post_init__(self):
         self.beams = self.beams
         self.name = self.name or "Unnamed Assembly"
@@ -256,7 +264,9 @@ def to_xml(self):
                 mesh = face.to_mesh()
                 mesh_vertices = mesh.Vertices
                 for idx, vertex in enumerate(mesh_vertices):
-                    facerhmesh_vertex_elem = ET.SubElement(facerhmesh_elem, "RhMeshVertex")
+                    facerhmesh_vertex_elem = ET.SubElement(
+                        facerhmesh_elem, "RhMeshVertex"
+                    )
                     facerhmesh_vertex_elem.set("x", str(vertex.X))
                     facerhmesh_vertex_elem.set("y", str(vertex.Y))
                     facerhmesh_vertex_elem.set("z", str(vertex.Z))
@@ -269,13 +279,13 @@ def to_xml(self):
                     facerhmesh_face_elem.set("v4", str(face.D))
 
         tree = ET.ElementTree(root)
-        xml_string = ET.tostring(root, encoding='unicode')
+        xml_string = ET.tostring(root, encoding="unicode")
         dom = parseString(xml_string)
         pretty_xml = dom.toprettyxml()
 
         return pretty_xml
 
-    def dump_xml(self, pretty_xml : str, dir: str):
+    def dump_xml(self, pretty_xml: str, dir: str):
         """
         Dump the pretty XML to a file
 
@@ -298,4 +308,4 @@ def all_joint_faces(self):
     def all_side_faces(self):
         for beam in self.beams:
             self._all_sidefaces.extend(beam.side_faces)
-        return self._all_sidefaces
+        return self._all_sidefaces

src/gh/diffCheck/diffCheck/__init__.py

@@ -5,12 +5,12 @@
 import typing
 from dataclasses import dataclass
 
-import df_util
+import diffCheck.df_util
 import diffCheck.df_transformations
-from diffCheck.df_geometries import DFFace
+
 
 @dataclass
-class JointDetector():
+class JointDetector:
     """
     This class is responsible for detecting joints in a brep
     """
@@ -25,9 +25,21 @@ def __post_init__(self):
         self._mix : typing.List[rg.Brep]= []
 
         # list of DFFaces from joints and sides
-        self._faces : typing.List[DFFace] = []
+        self._faces = []
+
+    def _compute_mass_center(self, b_face: rg.BrepFace) -> rg.Point3d:
+        """
+        Compute the mass center of a brep face
+
+        :param b_face: The brep face to compute the mass center from
+        :return mass_center: The mass center of the brep face
+        """
+        amp = rg.AreaMassProperties.Compute(b_face)
+        if amp:
+            return amp.Centroid
+        return None
 
-    def run(self) -> typing.List[DFFace]:
+    def run(self) :
         """
             Run the joint detector
 
@@ -73,7 +85,7 @@ def run(self) -> typing.List[DFFace]:
                     is_cut = False
                     is_hole = True
 
-                    b_faces = df_util.explode_brep(b)
+                    b_faces = diffCheck.df_util.explode_brep(b)
                     for b_face in b_faces:
                         if b_face.Faces[0].IsPlanar():
                             b_face_edges = b_face.Edges
@@ -109,7 +121,7 @@ def run(self) -> typing.List[DFFace]:
             # (5) check if closed, if it is 
             # ----------------------
             # (1) explode
-            faces_b = df_util.explode_brep(b)
+            faces_b = diffCheck.df_util.explode_brep(b)
 
             # (2) seperate in tow list flat surfaces (cuts + cylinder's bases) and non flat surfaces (cylinders)
             flat_faces_b = []
@@ -164,23 +176,23 @@ def run(self) -> typing.List[DFFace]:
             idx = idx + 1
             temp_face_centroids = []
             for f in b.Faces:
-                centroid = DFFace.compute_mass_center(f)
+                centroid = self._compute_mass_center(f)
                 temp_face_centroids.append(centroid)
             cuts_faces_centroids[idx] = temp_face_centroids
 
         # compare with the brep medians faces to get the joint/sides's faces
         for f in self.brep.Faces:
-            centroid_2test = DFFace.compute_mass_center(f)
+            centroid_2test = self._compute_mass_center(f)
             for key, centroids in cuts_faces_centroids.items():
                 is_joint = False
                 for centroid in centroids:
                     if centroid_2test.DistanceTo(centroid) < sc.doc.ModelAbsoluteTolerance:
-                        self._faces.append(DFFace.from_brep(f, key))
+                        self._faces.append([f, key])
                         is_joint = True
                         break
                 if is_joint:
                     break
             if not is_joint:
-                self._faces.append(DFFace.from_brep(f, None))
+                self._faces.append([f, None])
 
         return self._faces