topologicpy 0.7.83__py3-none-any.whl → 0.7.85__py3-none-any.whl

topologicpy/Topology.py

@@ -286,7 +286,7 @@ class Topology():
                     usedTopologies.append(0)
             ap = 1
             for aperture in apertures:
-                apCenter = Topology.InternalVertex(aperture, tolerance)
+                apCenter = Topology.InternalVertex(aperture, tolerance=tolerance)
                 for i in range(len(subTopologies)):
                     subTopology = subTopologies[i]
                     if exclusive == True and usedTopologies[i] == 1:
@@ -319,7 +319,7 @@ class Topology():
             subTopologies = [topology]
         else:
             subTopologies = Topology.SubTopologies(topology, subTopologyType)
-        processApertures(subTopologies, apertures, exclusive, tolerance)
+        processApertures(subTopologies, apertures, exclusive, tolerance=tolerance)
         return topology
     
     @staticmethod
@@ -1524,7 +1524,7 @@ class Topology():
         from topologicpy.CellComplex import CellComplex
         from topologicpy.Cluster import Cluster
 
-        def topologyByFaces(faces, topologyType, tolerance):
+        def topologyByFaces(faces, topologyType, tolerance=0.0001):
             if len(faces) == 1:
                 return faces[0]
 
@@ -1663,7 +1663,7 @@ class Topology():
             The created topology. The topology will have a dictionary embedded in it that records the input attributes (color, id, lengthUnit, name, type)
 
         """
-        def topologyByFaces(faces, outputMode, tolerance):
+        def topologyByFaces(faces, outputMode, tolerance=0.0001):
             output = None
             if len(faces) == 1:
                 return faces[0]
@@ -2386,6 +2386,10 @@ class Topology():
 
         import ifcopenshell, ifcopenshell.geom
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Face import Face
+        import numpy as np
 
         def get_psets(entity):
             # Initialize the PSET dictionary for this entity
@@ -2506,47 +2510,55 @@ class Topology():
                 color = (random.random(), random.random(), random.random())
             
             return color, default_transparency, material_list
-        
+        # Create a 4x4 unity matrix
+        matrix = [[1.0 if i == j else 0.0 for j in range(4)] for i in range(4)]
         def convert_to_topology(entity, settings, transferDictionaries=False):    
             if hasattr(entity, "Representation") and entity.Representation:
                 for rep in entity.Representation.Representations:
                     if rep.is_a("IfcShapeRepresentation"):
                         # Generate the geometry for this entity
                         shape = ifcopenshell.geom.create_shape(settings, entity)
-                        shape_geometry = shape.geometry
-                        verts = shape_geometry.verts
-                        verts = [ [verts[i], verts[i + 1], verts[i + 2]] for i in range(0, len(verts), 3)]
-                        edges = shape_geometry.edges
-                        edges = [[edges[i], edges[i + 1]] for i in range(0, len(edges), 2)]
-                        faces = shape_geometry.faces
-                        faces = [ [faces[i], faces[i + 1], faces[i + 2]] for i in range(0, len(faces), 3)]
-                        # Convert geometry to Topologic format
+                        try:
+                            trans = shape.transformation
+                            # Convert into a 4x4 matrix
+                            matrix = [trans.matrix[i:i+4] for i in range(0, len(trans.matrix), 4)]
+                        except:
+                            pass
+                        # Get grouped vertices and grouped faces     
+                        grouped_verts = shape.geometry.verts
+                        verts = [ [grouped_verts[i], grouped_verts[i + 1], grouped_verts[i + 2]] for i in range(0, len(grouped_verts), 3)]
+                        grouped_edges = shape.geometry.edges
+                        edges = [[grouped_edges[i], grouped_edges[i + 1]] for i in range(0, len(grouped_edges), 2)]
+                        grouped_faces = shape.geometry.faces
+                        faces = [ [grouped_faces[i], grouped_faces[i + 1], grouped_faces[i + 2]] for i in range(0, len(grouped_faces), 3)]
                         #shape_topology = ifc_to_topologic_geometry(verts, edges, faces)
                         #shape_topology = Topology.SelfMerge(Topology.ByGeometry(verts, edges, faces))
                         shape_topology = Topology.ByGeometry(verts, edges, faces, silent=True)
-                        if removeCoplanarFaces == True:
-                            shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
-
-                        # Store relevant information
-                        if transferDictionaries == True:
-                            color, transparency, material_list = get_color_transparency_material(entity)
-                            entity_dict = {
-                                "TOPOLOGIC_id": str(Topology.UUID(shape_topology)),
-                                "TOPOLOGIC_name": getattr(entity, 'Name', "Untitled"),
-                                "TOPOLOGIC_type": Topology.TypeAsString(shape_topology),
-                                "TOPOLOGIC_color": color,
-                                "TOPOLOGIC_opacity": 1.0 - transparency,
-                                "IFC_global_id": getattr(entity, 'GlobalId', 0),
-                                "IFC_name": getattr(entity, 'Name', "Untitled"),
-                                "IFC_type": entity.is_a(),
-                                "IFC_material_list": material_list,
-                            }
-                            topology_dict = Dictionary.ByPythonDictionary(entity_dict)
-                            # Get PSETs dictionary
-                            pset_python_dict = get_psets(entity)
-                            pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
-                            topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
-                            shape_topology = Topology.SetDictionary(shape_topology, topology_dict)
+                        if not shape_topology == None:
+                            if removeCoplanarFaces == True:
+                                shape_topology = Topology.RemoveCoplanarFaces(shape_topology, epsilon=0.0001)
+                            shape_topology = Topology.Transform(shape_topology, matrix)
+
+                            # Store relevant information
+                            if transferDictionaries == True:
+                                color, transparency, material_list = get_color_transparency_material(entity)
+                                entity_dict = {
+                                    "TOPOLOGIC_id": str(Topology.UUID(shape_topology)),
+                                    "TOPOLOGIC_name": getattr(entity, 'Name', "Untitled"),
+                                    "TOPOLOGIC_type": Topology.TypeAsString(shape_topology),
+                                    "TOPOLOGIC_color": color,
+                                    "TOPOLOGIC_opacity": 1.0 - transparency,
+                                    "IFC_global_id": getattr(entity, 'GlobalId', 0),
+                                    "IFC_name": getattr(entity, 'Name', "Untitled"),
+                                    "IFC_type": entity.is_a(),
+                                    "IFC_material_list": material_list,
+                                }
+                                topology_dict = Dictionary.ByPythonDictionary(entity_dict)
+                                # Get PSETs dictionary
+                                pset_python_dict = get_psets(entity)
+                                pset_dict = Dictionary.ByPythonDictionary(pset_python_dict)
+                                topology_dict = Dictionary.ByMergedDictionaries([topology_dict, pset_dict])
+                                shape_topology = Topology.SetDictionary(shape_topology, topology_dict)
                         return shape_topology
             return None
 
@@ -4184,7 +4196,6 @@ class Topology():
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Helper import Helper
         import inspect
-        print("input topologies:", topologies)
 
         topologies_list = []
         if Topology.IsInstance(topologies, "Topology"):
@@ -6229,7 +6240,7 @@ class Topology():
             return Topology.Type(topology)
 
     @staticmethod
-    def InternalVertex(topology, tolerance: float = 0.0001):
+    def _InternalVertex(topology, tolerance: float = 0.0001):
         """
         Returns a vertex guaranteed to be inside the input topology.
 
@@ -6284,11 +6295,54 @@ class Topology():
         elif Topology.IsInstance(top, "Vertex"): #Vertex
             vst = top
         elif Topology.IsInstance(topology, "Aperture"): #Aperture
-            vst = Face.InternalVertex(Aperture.Topology(top), tolerance)
+            vst = Face.InternalVertex(Aperture.Topology(top), tolerance=tolerance)
         else:
             vst = Topology.Centroid(top)
         return vst
 
+    
+
+    @staticmethod
+    def InternalVertex(topology, timeout: int = 10, tolerance: float = 0.0001):
+        """
+        Returns a vertex guaranteed to be inside the input topology.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        timeout : int , optional
+            The amount of seconds to wait before timing out. The default is 10 seconds.
+        tolerance : float , ptional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Vertex
+            A vertex guaranteed to be inside the input topology.
+
+        """
+        import concurrent.futures
+        import time
+        # Wrapper function with timeout
+        def run_with_timeout(func, topology, tolerance=0.0001, timeout=10):
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(func, topology, tolerance=tolerance)
+                try:
+                    result = future.result(timeout=timeout)  # Wait for the result with a timeout
+                    return result
+                except concurrent.futures.TimeoutError:
+                    print("Function took too long, retrying with a different solution.")
+                    return None  # or try another approach here
+
+        result = run_with_timeout(Topology._InternalVertex, topology=topology, tolerance=tolerance, timeout=timeout)  # Set a 10 second timeout
+        if result is None:
+            # Handle failure case (e.g., try a different solution)
+            print("Using a different approach.")
+            result = Topology.Centroid(topology)
+            print("Result is:", result)
+        return result
+
     @staticmethod
     def IsInstance(topology, type: str):
         """
@@ -6372,7 +6426,7 @@ class Topology():
         """
         from topologicpy.Vertex import Vertex
 
-        def isOnPlane(v, plane, tolerance):
+        def isOnPlane(v, plane, tolerance=0.0001):
             x, y, z = v
             a, b, c, d = plane
             if math.fabs(a*x + b*y + c*z + d) <= tolerance:
@@ -6403,7 +6457,7 @@ class Topology():
         else:
             p = plane(vertices[0], vertices[1], vertices[2])
             for i in range(len(vertices)):
-                if isOnPlane([Vertex.X(vertices[i], mantissa=mantissa), Vertex.Y(vertices[i], mantissa=mantissa), Vertex.Z(vertices[i], mantissa=mantissa)], p, tolerance) == False:
+                if isOnPlane([Vertex.X(vertices[i], mantissa=mantissa), Vertex.Y(vertices[i], mantissa=mantissa), Vertex.Z(vertices[i], mantissa=mantissa)], p, tolerance=tolerance) == False:
                     result = False
                     break
         return result
@@ -6749,8 +6803,13 @@ class Topology():
         from topologicpy.Cell import Cell
         from topologicpy.CellComplex import CellComplex
         from topologicpy.Cluster import Cluster
-        
+        import inspect
         if not Topology.IsInstance(topology, "Topology"):
+            if not silent:
+                print("Topology.RemoveCollinearEdges - Error: The input topology parameter is not a valid topology. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         return_topology = topology
         if Topology.IsInstance(topology, "Vertex") or Topology.IsInstance(topology, "Edge"): #Vertex or Edge or Cluster, return the original topology
@@ -6776,7 +6835,7 @@ class Topology():
             topologies += Cluster.FreeEdges(topology)
             faces = Topology.Faces(topology)
             for face in faces:
-                topologies.append(Face.RemoveCollinearEdges(topology, angTolerance=angTolerance, tolerance=tolerance))
+                topologies.append(Face.RemoveCollinearEdges(face, angTolerance=angTolerance, tolerance=tolerance))
             return_topology = Topology.SelfMerge(Cluster.ByTopologies(topologies), tolerance=tolerance)
         return return_topology
 
@@ -7865,14 +7924,14 @@ class Topology():
     @staticmethod
     def Show(*topologies,
              opacityKey = "opacity",
-             showVertices=True, vertexSize=1.1, vertexSizeKey = None, vertexColor="black", vertexColorKey = None,
+             showVertices=True, vertexSize=None, vertexSizeKey = None, vertexColor="black", vertexColorKey = None,
              vertexLabelKey=None, showVertexLabel= False,
              vertexGroupKey=None, vertexGroups=[], 
              vertexMinGroup=None, vertexMaxGroup=None, 
              showVertexLegend=False, vertexLegendLabel="Topology Vertices", vertexLegendRank=1, 
              vertexLegendGroup=1, 
 
-             showEdges=True, edgeWidth=1, edgeWidthKey = None, edgeColor="black", edgeColorKey = None,
+             showEdges=True, edgeWidth=None, edgeWidthKey = None, edgeColor="black", edgeColorKey = None,
              edgeLabelKey=None, showEdgeLabel = False,
              edgeGroupKey=None, edgeGroups=[], 
              edgeMinGroup=None, edgeMaxGroup=None, 
@@ -7932,7 +7991,7 @@ class Topology():
             The list of vertex groups against which to index the color of the vertex. The default is [].
         vertexMinGroup : int or float , optional
             For numeric vertexGroups, vertexMinGroup is the desired minimum value for the scaling of colors. This should match the type of value associated with the vertexGroupKey. If set to None, it is set to the minimum value in vertexGroups. The default is None.
-        edgeMaxGroup : int or float , optional
+        vertexMaxGroup : int or float , optional
             For numeric vertexGroups, vertexMaxGroup is the desired maximum value for the scaling of colors. This should match the type of value associated with the vertexGroupKey. If set to None, it is set to the maximum value in vertexGroups. The default is None.
         showVertexLegend : bool, optional
             If set to True, the legend for the vertices of this topology is shown. Otherwise, it isn't. The default is False.
@@ -8101,23 +8160,70 @@ class Topology():
             if not silent:
                 print("Topology.Show - Error: the input topologies parameter does not contain any valid topology. Returning None.")
             return None
+        
         if camera[0] == 0 and camera[1] == 0 and up == [0,0,1]:
             up = [0,1,0] #default to positive Y axis being up if looking down or up at the XY plane
         data = []
         for topology in new_topologies:
             if Topology.IsInstance(topology, "Graph"):
-                data += Plotly.DataByGraph(topology, sagitta=sagitta, absolute=absolute, sides=sides,  angle=angle, vertexColor=vertexColor, vertexColorKey=vertexColorKey, vertexSize=vertexSize, vertexSizeKey=vertexSizeKey, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabel=showVertexLabel, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeColorKey=edgeColorKey, edgeWidth=edgeWidth, edgeWidthKey=edgeWidthKey, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabel=showEdgeLabel, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
+                if vertexSize == None:
+                    vSize = 6
+                else:
+                    vSize = vertexSize
+                if edgeWidth == None:
+                    eWidth = 1
+                else:
+                    eWidth = edgeWidth
+                data += Plotly.DataByGraph(topology,
+                                           sagitta=sagitta,
+                                           absolute=absolute,
+                                           sides=sides,
+                                           angle=angle,
+                                           vertexColor=vertexColor,
+                                           vertexColorKey=vertexColorKey,
+                                           vertexSize=vSize,
+                                           vertexSizeKey=vertexSizeKey,
+                                           vertexLabelKey=vertexLabelKey,
+                                           vertexGroupKey=vertexGroupKey,
+                                           vertexGroups=vertexGroups,
+                                           vertexMinGroup=vertexMinGroup,
+                                           vertexMaxGroup=vertexMaxGroup,
+                                           showVertices=showVertices,
+                                           showVertexLabel=showVertexLabel,
+                                           showVertexLegend=showVertexLegend,
+                                           edgeColor=edgeColor,
+                                           edgeColorKey=edgeColorKey,
+                                           edgeWidth=eWidth,
+                                           edgeWidthKey=edgeWidthKey,
+                                           edgeLabelKey=edgeLabelKey,
+                                           edgeGroupKey=edgeGroupKey,
+                                           edgeGroups=edgeGroups,
+                                           edgeMinGroup=edgeMinGroup,
+                                           edgeMaxGroup=edgeMaxGroup,
+                                           showEdges=showEdges,
+                                           showEdgeLabel=showEdgeLabel,
+                                           showEdgeLegend=showEdgeLegend,
+                                           colorScale=colorScale,
+                                           silent=silent)
             else:
+                if vertexSize == None:
+                    vSize = 1.1
+                else:
+                    vSize = vertexSize
+                if edgeWidth == None:
+                    eWidth = 1
+                else:
+                    eWidth = edgeWidth
                 d = Topology.Dictionary(topology)
                 if not d == None:
                     faceOpacity = Dictionary.ValueAtKey(d, opacityKey) or faceOpacity
                 data += Plotly.DataByTopology(topology=topology,
-                            showVertices=showVertices, vertexSize=vertexSize, vertexSizeKey=vertexSizeKey, vertexColor=vertexColor, vertexColorKey=vertexColorKey,
+                            showVertices=showVertices, vertexSize=vSize, vertexSizeKey=vertexSizeKey, vertexColor=vertexColor, vertexColorKey=vertexColorKey,
                             vertexLabelKey=vertexLabelKey, showVertexLabel=showVertexLabel, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, 
                             vertexMinGroup=vertexMinGroup, vertexMaxGroup=vertexMaxGroup, 
                             showVertexLegend=showVertexLegend, vertexLegendLabel=vertexLegendLabel, vertexLegendRank=vertexLegendRank,
                             vertexLegendGroup=vertexLegendGroup,
-                            showEdges=showEdges, edgeWidth=edgeWidth, edgeWidthKey=edgeWidthKey, edgeColor=edgeColor, edgeColorKey=edgeColorKey,
+                            showEdges=showEdges, edgeWidth=eWidth, edgeWidthKey=edgeWidthKey, edgeColor=edgeColor, edgeColorKey=edgeColorKey,
                             edgeLabelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, 
                             edgeMinGroup=edgeMinGroup, edgeMaxGroup=edgeMaxGroup, 
                             showEdgeLegend=showEdgeLegend, edgeLegendLabel=edgeLegendLabel, edgeLegendRank=edgeLegendRank, 
@@ -8172,7 +8278,7 @@ class Topology():
             found = False
             for j in range(len(topologies)):
                 if usedTopologies[j] == 0:
-                    if Vertex.IsInternal( selectors[i], topologies[j], tolerance):
+                    if Vertex.IsInternal( selectors[i], topologies[j], tolerance=tolerance):
                         sortedTopologies.append(topologies[j])
                         if exclusive == True:
                             usedTopologies[j] = 1
@@ -8309,7 +8415,7 @@ class Topology():
                     returnTopology = Cell.ByShell(returnTopology)
                 except:
                     try:
-                        returnTopology = CellComplex.ByWires(topologies, tolerance)
+                        returnTopology = CellComplex.ByWires(topologies, tolerance=tolerance)
                         try:
                             returnTopology = CellComplex.ExternalBoundary(returnTopology)
                         except:
@@ -8336,7 +8442,7 @@ class Topology():
             for t in topologies:
                 external_wires.append(topologic.Face.ExternalBoundary(t))
             try:
-                returnTopology = CellComplex.ByWires(external_wires, tolerance)
+                returnTopology = CellComplex.ByWires(external_wires, tolerance=tolerance)
             except:
                 try:
                     returnTopology = Shell.ByWires(external_wires, triangulate=triangulate, tolerance=tolerance, silent=True)
@@ -8846,7 +8952,7 @@ class Topology():
         mergingProcess = MergingProcess(queue, sources_str, sink_items, so_dicts)
         mergingProcess.start()
 
-        workerProcessPool = WorkerProcessPool(numWorkers, queue, sources_str, sink_items, so_dicts, tolerance)
+        workerProcessPool = WorkerProcessPool(numWorkers, queue, sources_str, sink_items, so_dicts, tolerance=tolerance)
         workerProcessPool.startProcesses()
         workerProcessPool.join()
 
@@ -9045,7 +9151,7 @@ class Topology():
         r_shells = Topology.Shells(return_topology)
         r_cells = Topology.Cells(return_topology)
         r_cellComplexes = Topology.CellComplexes(return_topology)
-        
+
         for i, t in enumerate(r_vertices):
             t = Topology.SetDictionary(t, Topology.Dictionary(vertices[i]), silent=True)
         for i, t in enumerate(r_edges):

topologicpy/Vertex.py

@@ -771,7 +771,7 @@ class Vertex():
         from topologicpy.Topology import Topology
         import numpy as np
 
-        def fuse_vertices(vertices, tolerance):
+        def fuse_vertices(vertices, tolerance=0.0001):
             fused_vertices = []
             merged_indices = {}
 
@@ -818,7 +818,7 @@ class Vertex():
             return None
         
         vertices = [(Vertex.X(v, mantissa=mantissa), Vertex.Y(v, mantissa=mantissa), Vertex.Z(v, mantissa=mantissa)) for v in vertices]
-        fused_vertices = fuse_vertices(vertices, tolerance)
+        fused_vertices = fuse_vertices(vertices, tolerance=tolerance)
         return_vertices = [Vertex.ByCoordinates(list(coord)) for coord in fused_vertices]
         return return_vertices
 
@@ -1110,13 +1110,18 @@ class Vertex():
         import inspect
 
         if not Topology.IsInstance(vertex, "Vertex"):
-            print("Called from:", inspect.stack()[1][3])
             if not silent:
                 print("Vertex.IsInternal - Error: The input vertex parameter is not a valid vertex. Returning None.", vertex, topology)
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
         if not Topology.IsInstance(topology, "Topology"):
             if not silent:
                 print("Vertex.IsInternal - Error: The input topology parameter is not a valid topology. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
             return None
 
         if Topology.IsInstance(topology, "Vertex"):

topologicpy/Wire.py

@@ -1445,7 +1445,7 @@ class Wire():
         from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
 
-        def vIndex(v, vList, tolerance):
+        def vIndex(v, vList, tolerance=0.0001):
             for i in range(len(vList)):
                 if Vertex.Distance(v, vList[i]) < tolerance:
                     return i+1
@@ -1512,7 +1512,7 @@ class Wire():
 
         graph = []
         for anEdge in tEdges:
-            graph.append([vIndex(anEdge.StartVertex(), tVertices, tolerance), vIndex(anEdge.EndVertex(), tVertices, tolerance)])
+            graph.append([vIndex(anEdge.StartVertex(), tVertices, tolerance), vIndex(anEdge.EndVertex(), tVertices, tolerance)]) # Hook to Core
 
         cycles = []
         resultingCycles = main(graph, cycles, maxVertices)
@@ -2331,7 +2331,7 @@ class Wire():
                     j += k
             return False
 
-        def angleBetweenEdges(e1, e2, tolerance):
+        def angleBetweenEdges(e1, e2, tolerance=0.0001):
             a = e1.EndVertex().X() - e1.StartVertex().X()
             b = e1.EndVertex().Y() - e1.StartVertex().Y()
             c = e1.EndVertex().Z() - e1.StartVertex().Z()
@@ -2350,16 +2350,16 @@ class Wire():
             angleInDegrees = math.degrees(math.acos(angle))
             return angleInDegrees
 
-        def getInteriorAngles(edges, tolerance):
+        def getInteriorAngles(edges, tolerance=0.0001):
             angles = []
             for i in range(len(edges)-1):
                 e1 = edges[i]
                 e2 = edges[i+1]
-                angles.append(angleBetweenEdges(e1, e2, tolerance))
+                angles.append(angleBetweenEdges(e1, e2, tolerance=tolerance))
             return angles
 
-        def getRep(edges, tolerance):
-            angles = getInteriorAngles(edges, tolerance)
+        def getRep(edges, tolerance=0.0001):
+            angles = getInteriorAngles(edges, tolerance=tolerance)
             lengths = []
             for anEdge in edges:
                 lengths.append(Edge.Length(anEdge))
@@ -2379,8 +2379,8 @@ class Wire():
         _ = wireB.Edges(None, edgesB)
         if len(edgesA) != len(edgesB):
             return False
-        repA = getRep(list(edgesA), tolerance)
-        repB = getRep(list(edgesB), tolerance)
+        repA = getRep(list(edgesA), tolerance=tolerance)
+        repB = getRep(list(edgesB), tolerance=tolerance)
         if isCyclicallyEquivalent(repA, repB, tolerance, angTolerance):
             return True
         if isCyclicallyEquivalent(repA, repB[::-1], tolerance, angTolerance):
@@ -2966,12 +2966,107 @@ class Wire():
         if direction != [0, 0, 1]:
             baseWire = Topology.Orient(baseWire, origin=origin, dirA=[0, 0, 1], dirB=direction)
         return baseWire
-    
+
+
     @staticmethod
     def RemoveCollinearEdges(wire, angTolerance: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
         Removes any collinear edges in the input wire.
 
+        Parameters
+        ----------
+        wire : topologic_core.Wire
+            The input wire.
+        angTolerance : float, optional
+            The desired angular tolerance. The default is 0.1.
+        tolerance : float, optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool, optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        topologic_core.Wire
+            The wire without collinear edges, or the original wire if no modifications were necessary.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+
+        def cleanup(wire):
+            """Fuses vertices and removes edges below the tolerance distance."""
+            vertices = Vertex.Fuse(Topology.Vertices(wire), tolerance=tolerance)
+            edges = Topology.Edges(wire)
+            new_edges = []
+
+            for edge in edges:
+                sv = vertices[Vertex.Index(Edge.StartVertex(edge), vertices, tolerance=tolerance)]
+                ev = vertices[Vertex.Index(Edge.EndVertex(edge), vertices, tolerance=tolerance)]
+                if Vertex.Distance(sv, ev) > tolerance:
+                    new_edges.append(Edge.ByVertices([sv, ev]))
+
+            return Topology.SelfMerge(Cluster.ByTopologies(new_edges, silent=silent), tolerance=tolerance) if new_edges else wire
+
+        def remove_collinear_vertices(wire):
+            """Removes collinear vertices from a wire."""
+            if not Topology.IsInstance(wire, "Wire"):
+                return wire
+
+            vertices = Topology.Vertices(wire)
+            filtered_vertices = []
+
+            for i, vertex in enumerate(vertices):
+                edges = Topology.SuperTopologies(topology=vertex, hostTopology=wire, topologyType="edge")
+
+                if len(edges) != 2:
+                    filtered_vertices.append(vertex)
+                elif not Edge.IsCollinear(edges[0], edges[1], tolerance=tolerance):
+                    filtered_vertices.append(vertex)
+
+            if len(filtered_vertices) > 2:
+                return Wire.ByVertices(filtered_vertices, close=wire.IsClosed())
+            elif len(filtered_vertices) == 2:
+                return Edge.ByStartVertexEndVertex(filtered_vertices[0], filtered_vertices[1], tolerance=tolerance, silent=True)
+            else:
+                return wire
+
+        # Main function logic
+        if Topology.IsInstance(wire, "Cluster"):
+            wires = Topology.Wires(wire)
+            processed_wires = [Wire.RemoveCollinearEdges(w, angTolerance, tolerance, silent) for w in wires]
+            if len(processed_wires) == 0:
+                if not silent:
+                    print("Wire.RemoveCollinearEdges - Error: No wires were produced. Returning None.")
+                return None
+            elif len(processed_wires) == 1:
+                return Topology.SelfMerge(processed_wires[0])
+            else:
+                return Topology.SelfMerge(Cluster.ByTopologies(processed_wires, silent=silent))
+
+        if not Topology.IsInstance(wire, "Wire"):
+            if not silent:
+                print(f"Wire.RemoveCollinearEdges - Error: Input is not a valid wire. Returning None.")
+            return None
+
+        new_wire = cleanup(wire)
+        wires = Wire.Split(new_wire) if not Wire.IsManifold(new_wire) else [new_wire]
+
+        processed_wires = [remove_collinear_vertices(w) for w in wires]
+
+        if len(processed_wires) == 0:
+            return wire
+        elif len(processed_wires) == 1:
+            return Topology.SelfMerge(processed_wires[0])
+        else:
+            return Topology.SelfMerge(Cluster.ByTopologies(processed_wires, silent=silent))
+
+    @staticmethod
+    def RemoveCollinearEdges_old(wire, angTolerance: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Removes any collinear edges in the input wire.
+
         Parameters
         ----------
         wire : topologic_core.Wire
@@ -2996,7 +3091,7 @@ class Wire():
         from topologicpy.Topology import Topology
         import inspect
         
-        def cleanup(wire, tolerance):
+        def cleanup(wire, tolerance=0.0001):
             vertices = Topology.Vertices(wire)
             vertices = Vertex.Fuse(vertices, tolerance=tolerance)
             edges = Topology.Edges(wire)
@@ -3051,8 +3146,6 @@ class Wire():
                 return result
         if not Topology.IsInstance(wire, "Wire"):
             if not silent:
-                print("The wire is:", wire)
-                Topology.Show(wire)
                 print("Wire.RemoveCollinearEdges - Error: The input wire parameter is not a valid wire. Returning None.")
                 curframe = inspect.currentframe()
                 calframe = inspect.getouterframes(curframe, 2)
@@ -3300,7 +3393,7 @@ class Wire():
 
             return numerator / denominator
 
-        def douglas_peucker(wire, tolerance):
+        def douglas_peucker(wire, tolerance=0.0001):
             if isinstance(wire, list):
                 points = wire
             else:
@@ -3323,12 +3416,12 @@ class Wire():
             if max_distance <= tolerance:
                 return [start_point, end_point]
 
-            first_segment = douglas_peucker(points[:max_index + 1], tolerance)
-            second_segment = douglas_peucker(points[max_index:], tolerance)
+            first_segment = douglas_peucker(points[:max_index + 1], tolerance=tolerance)
+            second_segment = douglas_peucker(points[max_index:], tolerance=tolerance)
 
             return first_segment[:-1] + second_segment
 
-        def visvalingam_whyatt(wire, tolerance):
+        def visvalingam_whyatt(wire, tolerance=0.0001):
             if isinstance(wire, list):
                 points = wire
             else:
@@ -3360,7 +3453,7 @@ class Wire():
 
             return simplified_points
 
-        def reumann_witkam(wire, tolerance):
+        def reumann_witkam(wire, tolerance=0.0001):
             if isinstance(wire, list):
                 points = wire
             else:

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.83'
+__version__ = '0.7.85'

{topologicpy-0.7.83.dist-info → topologicpy-0.7.85.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.83
+Version: 0.7.85
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License