topologicpy 0.7.11__py3-none-any.whl → 0.7.14__py3-none-any.whl

topologicpy/Cell.py

@@ -566,7 +566,7 @@ class Cell():
         from topologicpy.Topology import Topology
         from topologicpy.Cell import Cell
         from topologicpy.Vertex import Vertex
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Capsule - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -652,8 +652,10 @@ class Cell():
             The radius of the top circle of the cone. The default is 0.
         height : float , optional
             The height of the cone. The default is 1.
-        sides : int , optional
-            The number of sides of the cone. The default is 16.
+        uSides : int , optional
+            The number of circle segments of the cylinder. The default is 16.
+        vSides : int , optional
+            The number of vertical segments of the cylinder. The default is 1.
         direction : list , optional
             The vector representing the up direction of the cone. The default is [0, 0, 1].
         placement : str , optional
@@ -697,7 +699,7 @@ class Cell():
             f = Face.ByWire(w, tolerance=tolerance)
             faces.append(f)
             return Cell.ByFaces(faces, tolerance=tolerance)
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Cone - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -839,7 +841,7 @@ class Cell():
         from topologicpy.CellComplex import CellComplex
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Cylinder - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -1014,7 +1016,7 @@ class Cell():
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
 
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Dodecahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -1113,7 +1115,7 @@ class Cell():
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
 
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Sphere - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -1280,7 +1282,7 @@ class Cell():
                 returnTopology = Cluster.ByTopologies(faces)
             return returnTopology
         
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Hyperboloid - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -1352,7 +1354,7 @@ class Cell():
         from topologicpy.Topology import Topology
         import math
 
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Dodecahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -1520,7 +1522,7 @@ class Cell():
         from topologicpy.Face import Face
         from topologicpy.Topology import Topology
 
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Octahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -1751,7 +1753,7 @@ class Cell():
         from topologicpy.Face import Face
         from topologicpy.Topology import Topology
 
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Prism - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -1965,7 +1967,7 @@ class Cell():
         from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
 
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Sphere - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -2039,7 +2041,7 @@ class Cell():
         from topologicpy.Topology import Topology
         import math
 
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Tetrahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -2100,7 +2102,7 @@ class Cell():
         from topologicpy.Wire import Wire
         from topologicpy.Topology import Topology
         
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Cell.Torus - Error: The input origin parameter is not a valid topologic vertex. Returning None.")

topologicpy/CellComplex.py

@@ -678,6 +678,29 @@ class CellComplex():
         """
         return cellComplex.ExternalBoundary()
 
+    @staticmethod
+    def ExternalBoundary(cellComplex):
+        """
+        Returns the external boundary (cell) of the input cellComplex.
+
+        Parameters
+        ----------
+        cellComplex : topologic_core.CellComplex
+            The input cellComplex.
+
+        Returns
+        -------
+        topologic_core.Cell
+            The external boundary of the input cellComplex.
+
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(cellComplex, "CellComplex"):
+            print("CellComplex.ExternalBoundary - Error: The input cellComplex parameter is not a valid cellComplex. Returning None.")
+            return None
+        return cellComplex.ExternalBoundary()
+    
     @staticmethod
     def ExternalFaces(cellComplex) -> list:
         """
@@ -795,7 +818,7 @@ class CellComplex():
         from topologicpy.Face import Face
         from topologicpy.Topology import Topology
 
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):
             print("CellComplex.Octahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")

topologicpy/Edge.py

@@ -444,50 +444,98 @@ class Edge():
         return Edge.ByVertices([sve, eve], tolerance=tolerance, silent=True)
 
     @staticmethod
-    def ExtendToEdge2D(edgeA, edgeB, tolerance: float = 0.0001):
+    def ExtendToEdge(edgeA, edgeB, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
-        Extends the first input edge to meet the second input edge. This works only in the XY plane. Z coordinates are ignored.
+        Extends the first input edge to meet the second input edge.
 
         Parameters
         ----------
         edgeA : topologic_core.Edge
-            The first input edge.
+            The first input edge. This edge will be extended to meet edgeB.
         edgeB : topologic_core.Edge
-            The second input edge.
+            The second input edge. This edge will be used to extend edgeA.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, not error or warning messages are printed. Otherwise, they are. The default is False.
         
         Returns
         -------
         topologic_core.Edge
-            The extended edge.
+            The trimmed edge.
 
         """
-
         from topologicpy.Vertex import Vertex
+        from topologicpy.Vector import Vector
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(edgeA, "Edge"):
-            print("Edge.ExtendToEdge2D - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
+            if not silent:
+                print("Edge.ExtendToEdge - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
             return None
         if not Topology.IsInstance(edgeB, "Edge"):
-            print("Edge.ExtendToEdge2D - Error: The input edgeB parameter is not a valid topologic edge. Returning None.")
+            if not silent:
+                print("Edge.ExtendToEdge - Error: The input edgeB parameter is not a valid topologic edge. Returning None.")
             return None
+        if not Edge.IsCoplanar(edgeA, edgeB, mantissa=mantissa, tolerance=tolerance):
+            if not silent:
+                print("Edge.ExtendToEdge - Error: The input edges are not coplanar. Returning the original edge.")
+            return edgeA
+        if not Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
+            if not silent:
+                print("Edge.ExtendToEdge - Error: The input edges are parallel. Returning the original edge.")
+            return edgeA
+        
         sva = Edge.StartVertex(edgeA)
         eva = Edge.EndVertex(edgeA)
-        intVertex = Edge.Intersect2D(edgeA, edgeB)
-        if intVertex and not (Vertex.IsInternal(intVertex, edgeA)):
-            e1 = Edge.ByVertices([sva, intVertex], tolerance=tolerance, silent=True)
-            e2 = Edge.ByVertices([eva, intVertex], tolerance=tolerance, silent=True)
-            l1 = Edge.Length(e1)
-            l2 = Edge.Length(e2)
-            if l1 > l2:
-                return e1
-            else:
-                return e2
-        print("Edge.ExtendToEdge2D - Error: The operation failed. Returning None.")
+        d1 = Vertex.Distance(sva, edgeB)
+        d2 = Vertex.Distance(eva, edgeB)
+        edge_direction = Edge.Direction(edgeA)
+        if d1 < d2:
+            v1 = eva
+            v2 = sva
+            edge_direction = Vector.Reverse(edge_direction)
+        else:
+            v1 = sva
+            v2 = eva
+        
+        d = max(d1, d2)*2
+        v2 = Topology.TranslateByDirectionDistance(v2, direction=edge_direction, distance=d)
+        new_edge = Edge.ByVertices(v1, v2)
+        
+        svb = Edge.StartVertex(edgeB)
+        evb = Edge.EndVertex(edgeB)
+
+        intVertex = Topology.Intersect(new_edge, edgeB, tolerance=tolerance)
+        if intVertex:
+            return Edge.ByVertices([v1, intVertex], tolerance=tolerance, silent=True)
+        print("Edge.ExtendToEdge - Error: The operation failed. Returning None.")
         return None
     
+    @staticmethod
+    def ExternalBoundary(edge):
+        """
+        Returns the external boundary (cluster of end vertices) of the input edge.
+
+        Parameters
+        ----------
+        edge : topologic_core.Edge
+            The input edge.
+
+        Returns
+        -------
+        topologic_core.Cluster
+            The external boundary of the input edge. This is a cluster of the edge's end vertices.
+
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Cluster import Cluster
+
+        if not Topology.IsInstance(edge, "Edge"):
+            print("Edge.ExternalBoundary - Error: The input edge parameter is not a valid edge. Returning None.")
+            return None
+        return Cluster.ByTopologies([Edge.StartVertex(edge), Edge.EndVertex(edge)])
+    
     @staticmethod
     def Index(edge, edges: list, strict: bool = False, tolerance: float = 0.0001) -> int:
         """
@@ -542,67 +590,6 @@ class Edge():
                     return i
         return None
 
-    @staticmethod
-    def Intersect2D(edgeA, edgeB, mantissa: int = 6, silent: bool = False):
-        """
-        Returns the intersection of the two input edges as a topologic_core.Vertex. This works only in the XY plane. Z coordinates are ignored.
-
-        Parameters
-        ----------
-        edgeA : topologic_core.Edge
-            The first input edge.
-        edgeB : topologic_core.Edge
-            The second input edge.
-        mantissa : int , optional
-            The desired length of the mantissa. The default is 6.
-        silent : bool , optional
-            If set to False, error and warning messages are displayed. Otherwise they are not. The default is False.
-
-        Returns
-        -------
-        topologic_core.Vertex
-            The intersection of the two input edges.
-
-        """
-        from topologicpy.Vertex import Vertex
-        from topologicpy.Topology import Topology
-
-        if not Topology.IsInstance(edgeA, "Edge"):
-            if not silent:
-                print("Edge.Intersect2D - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
-            return None
-        if not Topology.IsInstance(edgeB, "Edge"):
-            if not silent:
-                print("Edge.Intersect2D - Error: The input edgeB parameter is not a valid topologic edge. Returning None.")
-            return None
-        sva = Edge.StartVertex(edgeA)
-        eva = Edge.EndVertex(edgeA)
-        svb = Edge.StartVertex(edgeB)
-        evb = Edge.EndVertex(edgeB)
-        # Line AB represented as a1x + b1y = c1
-        a1 = Vertex.Y(eva, mantissa=mantissa) - Vertex.Y(sva, mantissa=mantissa)
-        b1 = Vertex.X(sva, mantissa=mantissa) - Vertex.X(eva, mantissa=mantissa)
-        c1 = a1*(Vertex.X(sva, mantissa=mantissa)) + b1*(Vertex.Y(sva, mantissa=mantissa))
- 
-        # Line CD represented as a2x + b2y = c2
-        a2 = Vertex.Y(evb, mantissa=mantissa) - Vertex.Y(svb, mantissa=mantissa)
-        b2 = Vertex.X(svb, mantissa=mantissa) - Vertex.X(evb, mantissa=mantissa)
-        c2 = a2*(Vertex.X(svb, mantissa=mantissa)) + b2*(Vertex.Y(svb, mantissa=mantissa))
- 
-        determinant = a1*b2 - a2*b1
- 
-        if (determinant == 0):
-            # The lines are parallel. This is simplified
-            # by returning a pair of FLT_MAX
-            if not silent:
-                print("Edge.Intersect2D - Warning: The input edgeA and edgeB parameters are parallel edges. Returning None.")
-            return None
-        else:
-            x = (b2*c1 - b1*c2)/determinant
-            y = (a1*c2 - a2*c1)/determinant
-            return Vertex.ByCoordinates(x,y,0)
-
-
     @staticmethod
     def IsCollinear(edgeA, edgeB, mantissa: int = 6, tolerance: float = 0.0001) -> bool:
         """
@@ -686,7 +673,65 @@ class Edge():
         return bool(distance_start < tolerance) and bool(distance_end < tolerance)
     
     @staticmethod
-    def IsParallel(edgeA, edgeB, mantissa: int = 6, angTolerance: float = 0.1) -> bool:
+    def IsCoplanar(edgeA, edgeB, mantissa: int = 6, tolerance: float = 0.0001):
+        """
+        Return True if the two input edges are coplanar. Returns False otherwise.
+
+        Parameters
+        ----------
+        edgeA : topologic_core.Edge
+            The first input edge.
+        edgeB : topologic_core.Edge
+            The second input edge.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        bool
+            True if the two edges are coplanar. False otherwise.
+
+        """
+        import numpy as np
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(edgeA, "Edge"):
+            print("Edge.IsCoplanar - Error: The input parameter edgeA is not a valid edge. Returning None")
+            return None
+        if not Topology.IsInstance(edgeB, "Edge"):
+            print("Edge.IsCoplanar - Error: The input parameter edgeB is not a valid edge. Returning None")
+            return None
+        if Edge.Length(edgeA) < tolerance:
+            print("Edge.IsCoplanar - Error: The length of edgeA is less than the tolerance. Returning None")
+            return None
+        if Edge.Length(edgeB) < tolerance:
+            print("Edge.IsCoplanar - Error: The length of edgeB is less than the tolerance. Returning None")
+            return None
+        
+        # Extract points
+        sva, eva = [Topology.Vertices(edgeA)[0], Topology.Vertices(edgeA)[-1]]
+        p1 = Vertex.Coordinates(sva, mantissa=mantissa)
+        p2 = Vertex.Coordinates(eva, mantissa=mantissa)
+        svb, evb = [Topology.Vertices(edgeB)[0], Topology.Vertices(edgeB)[-1]]
+        p3 = Vertex.Coordinates(svb, mantissa=mantissa)
+        p4 = Vertex.Coordinates(evb, mantissa=mantissa)
+
+        # Create vectors
+        v1 = np.subtract(p2, p1)
+        v2 = np.subtract(p4, p3)
+        v3 = np.subtract(p3, p1)
+        
+        # Calculate the scalar triple product
+        scalar_triple_product = np.dot(np.cross(v1, v2), v3)
+        
+        # Check for coplanarity
+        return np.isclose(scalar_triple_product, 0, atol=tolerance)
+
+    @staticmethod
+    def IsParallel(edgeA, edgeB, mantissa: int = 6, tolerance: float = 0.0001) -> bool:
         """
         Return True if the two input edges are parallel. Returns False otherwise.
 
@@ -707,7 +752,9 @@ class Edge():
             True if the two edges are collinear. False otherwise.
 
         """
+        from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
+        import numpy as np
 
         if not Topology.IsInstance(edgeA, "Edge"):
             print("Edge.IsParallel - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
@@ -715,10 +762,38 @@ class Edge():
         if not Topology.IsInstance(edgeB, "Edge"):
             print("Edge.IsParallel - Error: The input edgeB parameter is not a valid topologic edge. Returning None.")
             return None
-        ang = Edge.Angle(edgeA, edgeB, mantissa=mantissa, bracket=True)
-        if abs(ang) < angTolerance or abs(180 - ang) < angTolerance:
-            return True
-        return False
+        
+        def are_lines_parallel(line1, line2, tolerance=0.0001):
+            """
+            Determines if two lines in 3D space are parallel.
+            
+            Parameters:
+            line1 (tuple): A tuple of two points defining the first line. Each point is a tuple of (x, y, z).
+            line2 (tuple): A tuple of two points defining the second line. Each point is a tuple of (x, y, z).
+            
+            Returns:
+            bool: True if the lines are parallel, False otherwise.
+            """
+            def vector_from_points(p1, p2):
+                return np.array([p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]])
+            
+            # Get direction vectors for both lines
+            vec1 = vector_from_points(line1[0], line1[1])
+            vec2 = vector_from_points(line2[0], line2[1])
+            
+            # Compute the cross product of the direction vectors
+            cross_product = np.cross(vec1, vec2)
+            
+            # Two vectors are parallel if their cross product is a zero vector
+            return np.allclose(cross_product, 0, atol=tolerance)
+
+        x1, y1, z1 = Vertex.Coordinates(Edge.StartVertex(edgeA), mantissa=mantissa)
+        x2, y2, z2 = Vertex.Coordinates(Edge.EndVertex(edgeA), mantissa=mantissa)
+        x3, y3, z3 = Vertex.Coordinates(Edge.StartVertex(edgeA), mantissa=mantissa)
+        x4, y4, z4 = Vertex.Coordinates(Edge.EndVertex(edgeA), mantissa=mantissa)
+        line1 = ((x1, y1, z1), (x2, y2, z2))
+        line2 = ((x3, y3, z3), (x4, y4, z4))
+        return are_lines_parallel(line1, line2, tolerance=tolerance)
 
     @staticmethod
     def Length(edge, mantissa: int = 6) -> float:
@@ -770,7 +845,7 @@ class Edge():
             1. "center" which places the center of the edge at the origin.
             2. "start" which places the start of the edge at the origin.
             3. "end" which places the end of the edge at the origin.
-            The default is "center".
+            The default is "center". It is case insensitive.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         Returns
@@ -783,7 +858,7 @@ class Edge():
         from topologicpy.Vector import Vector
         from topologicpy.Topology import Topology
 
-        if origin == None:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.Origin()
         if not Topology.IsInstance(origin, "Vertex"):
             print("Edge.Line - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -1126,18 +1201,22 @@ class Edge():
         return Edge.ByVertices([sve, eve], tolerance=tolerance, silent=True)
 
     @staticmethod
-    def TrimByEdge2D(edgeA, edgeB, reverse: bool = False, tolerance: float = 0.0001):
+    def TrimByEdge(edgeA, edgeB, reverse: bool = False, mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
-        Trims the first input edge by the second input edge. This works only in the XY plane. Z coordinates are ignored.
+        Trims the first input edge by the second input edge.
 
         Parameters
         ----------
         edgeA : topologic_core.Edge
-            The first input edge.
+            The first input edge. This edge will be trimmed by edgeB.
         edgeB : topologic_core.Edge
-            The second input edge.
+            The second input edge. This edge will be used to trim edgeA.
+        reverse : bool , optional
+            If set to True, which segment is preserved is reversed. Otherwise, it is not. The default is False.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, not error or warning messages are printed. Otherwise, they are. The default is False.
         
         Returns
         -------
@@ -1149,14 +1228,45 @@ class Edge():
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(edgeA, "Edge"):
-            print("Edge.TrimByEdge2D - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
+            if not silent:
+                print("Edge.TrimByEdge - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
             return None
         if not Topology.IsInstance(edgeB, "Edge"):
-            print("Edge.TrimByEdge2D - Error: The input edgeB parameter is not a valid topologic edge. Returning None.")
+            if not silent:
+                print("Edge.TrimByEdge - Error: The input edgeB parameter is not a valid topologic edge. Returning None.")
             return None
+        if not Edge.IsCoplanar(edgeA, edgeB, mantissa=mantissa, tolerance=tolerance):
+            if not silent:
+                print("Edge.TrimByEdge - Error: The input edges are not coplanar. Returning the original edge.")
+            return edgeA
+        if not Edge.IsParallel(edgeA, edgeB, tolerance=tolerance):
+            if not silent:
+                print("Edge.TrimByEdge - Error: The input edges are parallel. Returning the original edge.")
+            return edgeA
+        
+        sva = Edge.StartVertex(edgeA)
+        eva = Edge.EndVertex(edgeA)
+        svb = Edge.StartVertex(edgeB)
+        evb = Edge.EndVertex(edgeB)
+        intVertex = None
+        if Edge.IsCollinear(edgeA, edgeB):
+            if Vertex.IsInternal(svb, edgeA):
+                intVertex = svb
+            elif Vertex.IsInternal(evb, edgeA):
+                intVertex = evb
+            else:
+                intVertex = None
+            if intVertex:
+                if reverse:
+                        return Edge.ByVertices([eva, intVertex], tolerance=tolerance, silent=True)
+                else:
+                    return Edge.ByVertices([sva, intVertex], tolerance=tolerance, silent=True)
+            else:
+                return None
+        
         sva = Edge.StartVertex(edgeA)
         eva = Edge.EndVertex(edgeA)
-        intVertex = Edge.Intersect2D(edgeA, edgeB)
+        intVertex = Topology.Intersect(edgeA, edgeB)
         if intVertex and (Vertex.IsInternal(intVertex, edgeA)):
             if reverse:
                 return Edge.ByVertices([eva, intVertex], tolerance=tolerance, silent=True)
@@ -1195,7 +1305,7 @@ class Edge():
         if not Topology.IsInstance(edge, "Edge"):
             print("Edge.TrimByEdge2D - Error: The input edge parameter is not a valid topologic edge. Returning None.")
             return None
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = edge.StartVertex()
         if not Topology.IsInstance(origin, "Vertex"):
             print("Edge.TrimByEdge2D - Error: The input origin parameter is not a valid topologic vertex. Returning None.")

topologicpy/Face.py

@@ -341,7 +341,7 @@ class Face():
             print("Face.ByShell - Error: The input shell parameter is not a valid toplogic shell. Returning None.")
             return None
         
-        if origin == None:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Topology.Centroid(shell)
         if not Topology.IsInstance(origin, "Vertex"):
             print("Face.ByShell - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
@@ -683,7 +683,7 @@ class Face():
         """
         from topologicpy.Topology import Topology
         from topologicpy.Vertex import Vertex
-        if not origin:
+        if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.Origin()
         
         c = Face.Circle(origin=origin, radius=radius, sides=sides, direction=[0, 0, 1], placement="center", tolerance=tolerance)
@@ -780,7 +780,7 @@ class Face():
         return round(compactness, mantissa)
 
     @staticmethod
-    def CompassAngle(face, north: list = None, mantissa: int = 6) -> float:
+    def CompassAngle(face, north: list = None, mantissa: int = 6, tolerance: float = 0.0001) -> float:
         """
         Returns the horizontal compass angle in degrees between the normal vector of the input face and the input vector. The angle is measured in counter-clockwise fashion. Only the first two elements of the vectors are considered.
 
@@ -809,7 +809,7 @@ class Face():
         if not north:
             north = Vector.North()
         dirA = Face.NormalAtParameters(face,mantissa=mantissa)
-        return Vector.CompassAngle(vectorA=dirA, vectorB=north, mantissa=mantissa)
+        return Vector.CompassAngle(vectorA=dirA, vectorB=north, mantissa=mantissa, tolerance=tolerance)
 
     @staticmethod
     def Edges(face) -> list:
@@ -1216,7 +1216,7 @@ class Face():
         return inverted_face
 
     @staticmethod
-    def IsCoplanar(faceA, faceB, tolerance: float = 0.0001) -> bool:
+    def IsCoplanar(faceA, faceB, mantissa: int = 6, tolerance: float = 0.0001) -> bool:
         """
         Returns True if the two input faces are coplanar. Returns False otherwise.
 
@@ -1226,13 +1226,10 @@ class Face():
             The first input face.
         faceB : topologic_core.Face
             The second input face
+        mantissa : int , optional
+            The length of the desired mantissa. The default is 6.
         tolerance : float , optional
-            The desired tolerance. The deafault is 0.0001.
-
-        Raises
-        ------
-        Exception
-            Raises an exception if the angle between the two input faces cannot be determined.
+            The desired tolerance. The default is 0.0001.
 
         Returns
         -------
@@ -1240,8 +1237,23 @@ class Face():
             True if the two input faces are coplanar. False otherwise.
 
         """
-        from topologicpy.Vector import Vector
         from topologicpy.Topology import Topology
+        import warnings
+
+        try:
+            import numpy as np
+        except:
+            print("Face.IsCoplanar - Information: Installing required numpy library.")
+            try:
+                os.system("pip install numpy")
+            except:
+                os.system("pip install numpy --user")
+            try:
+                import numpy as np
+                print("Face.IsCoplanar - Information: numpy library installed successfully.")
+            except:
+                warnings.warn("Face.IsCoplanar - Error:: Could not import numpy. Please install the numpy library manually. Returning None.")
+                return None
 
         if not Topology.IsInstance(faceA, "Face"):
             print("Face.IsInide - Error: The input faceA parameter is not a valid topologic face. Returning None.")
@@ -1249,9 +1261,25 @@ class Face():
         if not Topology.IsInstance(faceB, "Face"):
             print("Face.IsInide - Error: The input faceB parameter is not a valid topologic face. Returning None.")
             return None
-        dirA = Face.NormalAtParameters(faceA, 0.5, 0.5, "xyz", 3)
-        dirB = Face.NormalAtParameters(faceB, 0.5, 0.5, "xyz", 3)
-        return Vector.IsCollinear(dirA, dirB)
+
+        def normalize_plane_coefficients(plane):
+            norm = np.linalg.norm(plane[:3])  # Normalize using the first three coefficients (a, b, c)
+            if norm == 0:
+                return plane
+            return [coef / norm for coef in plane]
+
+        def are_planes_coplanar(plane1, plane2, tolerance):
+            normalized_plane1 = normalize_plane_coefficients(plane1)
+            normalized_plane2 = normalize_plane_coefficients(plane2)
+            return np.allclose(normalized_plane1, normalized_plane2, atol=tolerance)
+        
+        eq_a = Face.PlaneEquation(faceA, mantissa=mantissa)
+        plane_a = [eq_a['a'], eq_a['b'], eq_a['c'], eq_a['d']]
+        plane_a = normalize_plane_coefficients(plane_a)
+        eq_b = Face.PlaneEquation(faceB, mantissa=mantissa)
+        plane_b = [eq_b['a'], eq_b['b'], eq_b['c'], eq_b['d']]
+        plane_b = normalize_plane_coefficients(plane_b)
+        return are_planes_coplanar(plane_a, plane_b, tolerance=tolerance)
 
     @staticmethod
     def Isovist(face, vertex, obstacles: list = [], direction: list = [0,1,0], fov: float = 360, mantissa: int = 6, tolerance: float = 0.0001):