topologicpy 0.4.95__py3-none-any.whl → 0.4.96__py3-none-any.whl

topologicpy/Cell.py

@@ -116,6 +116,8 @@ class Cell(Topology):
             If set to True, the input faces are planarized before building the cell. Otherwise, they are not. The default is False.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
 
         Returns
         -------
@@ -126,8 +128,8 @@ class Cell(Topology):
         from topologicpy.Vertex import Vertex
         from topologicpy.Wire import Wire
         from topologicpy.Face import Face
-        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
+
         if not isinstance(faces, list):
             if not silent:
                 print("Cell.ByFaces - Error: The input faces parameter is not a valid list. Returning None.")
@@ -159,9 +161,11 @@ class Cell(Topology):
                     face_vertices.append(all_vertices[index])
             new_w = Wire.ByVertices(face_vertices)
             if isinstance(new_w, topologic.Wire):
-                new_f = Face.ByWire(new_w)
+                new_f = Face.ByWire(new_w, silent=True)
                 if isinstance(new_f, topologic.Face):
                     new_faces.append(new_f)
+                elif isinstance(new_f, list):
+                    new_faces += new_f
         faceList = new_faces
         planarizedList = []
         enlargedList = []
@@ -175,15 +179,17 @@ class Cell(Topology):
                 centroid = Topology.Centroid(f)
                 n = Face.Normal(f)
                 v = Topology.Translate(centroid, n[0]*0.01,n[1]*0.01,n[2]*0.01)
-                if not Cell.IsInternal(cell, v):
+                if not Vertex.IsInternal(v, cell):
                     finalFaces.append(f)
             finalFinalFaces = []
             for f in finalFaces:
                 vertices = Face.Vertices(f)
                 w = Wire.Cycles(Face.ExternalBoundary(f), maxVertices=len(vertices))[0]
-                f1 = Face.ByWire(w, tolerance=tolerance)
+                f1 = Face.ByWire(w, tolerance=tolerance, silent=True)
                 if isinstance(f1, topologic.Face):
                     finalFinalFaces.append(f1)
+                elif isinstance(f1, list):
+                    finalFinalFaces += f1
             cell = topologic.Cell.ByFaces(finalFinalFaces, tolerance)
             if cell == None:
                 if not silent:
@@ -240,7 +246,7 @@ class Cell(Topology):
             sum_normal = Vector.Sum(normals)
             new_v = Topology.TranslateByDirectionDistance(v, direction=sum_normal, distance=Vector.Magnitude(sum_normal))
             new_vertices.append(new_v)
-        new_cell = Topology.SelfMerge(Topology.ReplaceVertices(cell, Topology.Vertices(cell), new_vertices))
+        new_cell = Topology.SelfMerge(Topology.ReplaceVertices(cell, Topology.Vertices(cell), new_vertices), tolerance=tolerance)
         return new_cell
     
     @staticmethod
@@ -399,6 +405,8 @@ class Cell(Topology):
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to False, error and warning messages are printed. Otherwise, they are not. The default is False.
 
         Raises
         ------
@@ -411,32 +419,11 @@ class Cell(Topology):
             The created cell.
 
         """
-        from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
         from topologicpy.Wire import Wire
         from topologicpy.Face import Face
         from topologicpy.Shell import Shell
-        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
-        from topologicpy.Dictionary import Dictionary
-
-        def cleanup(f):
-            origin = Topology.Centroid(f)
-            normal = Face.Normal(f)
-            flatFace = Topology.Flatten(f, origin=origin, direction=normal)
-            world_origin = Vertex.ByCoordinates(0,0,0)
-            # Retrieve the needed transformations
-            dictionary = Topology.Dictionary(flatFace)
-            xTran = Dictionary.ValueAtKey(dictionary,"x")
-            yTran = Dictionary.ValueAtKey(dictionary,"y")
-            zTran = Dictionary.ValueAtKey(dictionary,"z")
-            phi = Dictionary.ValueAtKey(dictionary,"phi")
-            theta = Dictionary.ValueAtKey(dictionary,"theta")
-
-            f = Topology.Rotate(f, origin=world_origin, x=0, y=1, z=0, degree=theta)
-            f = Topology.Rotate(f, origin=world_origin, x=0, y=0, z=1, degree=phi)
-            f = Topology.Translate(f, xTran, yTran, zTran)
-            return f
 
         if not isinstance(wires, list):
             if not silent:
@@ -611,9 +598,9 @@ class Cell(Topology):
             return None
         cyl_height = height - radius*2
         if cyl_height <= 0:
-            capsule = Cell.Sphere(origin=origin, radius=radius, uSides= uSides, vSides=vSidesEnds*2)
+            capsule = Cell.Sphere(origin=Vertex.Origin(), radius=radius, uSides= uSides, vSides=vSidesEnds*2)
         else:
-            cyl = Cell.Cylinder(origin=origin,
+            cyl = Cell.Cylinder(origin=Vertex.Origin(),
                                 radius=radius,
                                 height=cyl_height,
                                 uSides=uSides, vSides=vSidesMiddle, direction=[0,0,1], placement="center", tolerance=tolerance)
@@ -628,8 +615,9 @@ class Cell(Topology):
         if placement == "lowerleft":
             capsule = Topology.Translate(capsule, 0, 0, height/2)
             capsule = Topology.Translate(capsule, radius, radius)
+        
+        capsule = Topology.Orient(capsule, origin=Vertex.Origin(), dirA=[0,0,1], dirB=direction)
         capsule = Topology.Place(capsule, originA=Vertex.Origin(), originB=origin)
-        capsule = Topology.Orient(capsule, origin=origin, dirA=[0,0,1], dirB=direction)
         return capsule
 
     @staticmethod
@@ -1075,8 +1063,9 @@ class Cell(Topology):
             dodecahedron = Topology.Translate(dodecahedron, 0, 0, radius)
         elif placement == "lowerleft":
             dodecahedron = Topology.Translate(dodecahedron, radius, radius, radius)
+        
+        dodecahedron = Topology.Orient(dodecahedron, origin=Vertex.Origin(), dirA=[0,0,1], dirB=direction, tolerance=tolerance)
         dodecahedron = Topology.Place(dodecahedron, originA=Vertex.Origin(), originB=origin)
-        dodecahedron = Topology.Orient(dodecahedron, origin=origin, dirA=[0,0,1], dirB=direction, tolerance=tolerance)
         return dodecahedron
 
     @staticmethod
@@ -1152,8 +1141,8 @@ class Cell(Topology):
         return faces
 
     @staticmethod
-    def Hyperboloid(origin: topologic.Cell = None, baseRadius: float = 0.5, topRadius: float = 0.5, height: float = 1, sides: int = 16, direction: list = [0,0,1],
-                        twist: float = 360, placement: str = "center", tolerance: float = 0.0001) -> topologic.Cell:
+    def Hyperboloid(origin: topologic.Cell = None, baseRadius: float = 0.5, topRadius: float = 0.5, height: float = 1, sides: int = 24, direction: list = [0,0,1],
+                        twist: float = 60, placement: str = "center", tolerance: float = 0.0001) -> topologic.Cell:
         """
         Creates a hyperboloid.
 
@@ -1168,11 +1157,11 @@ class Cell(Topology):
         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.
+            The number of sides of the cone. The default is 24.
         direction : list , optional
             The vector representing the up direction of the hyperboloid. The default is [0,0,1].
         twist : float , optional
-            The angle to twist the base cylinder. The default is 360.
+            The angle to twist the base cylinder. The default is 60.
         placement : str , optional
             The description of the placement of the origin of the hyperboloid. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
         tolerance : float , optional
@@ -1218,6 +1207,7 @@ class Cell(Topology):
         if not isinstance(origin, topologic.Vertex):
             print("Cell.Hyperboloid - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
             return None
+        w_origin = Vertex.Origin()
         baseV = []
         topV = []
         xOffset = 0
@@ -1228,41 +1218,27 @@ class Cell(Topology):
         elif placement.lower() == "lowerleft":
             xOffset = max(baseRadius, topRadius)
             yOffset = max(baseRadius, topRadius)
-        baseZ = origin.Z() + zOffset
-        topZ = origin.Z() + zOffset + height
+        baseZ = w_origin.Z() + zOffset
+        topZ = w_origin.Z() + zOffset + height
         for i in range(sides):
             angle = math.radians(360/sides)*i
             if baseRadius > 0:
-                baseX = math.sin(angle+math.radians(twist))*baseRadius + origin.X() + xOffset
-                baseY = math.cos(angle+math.radians(twist))*baseRadius + origin.Y() + yOffset
-                baseZ = origin.Z() + zOffset
+                baseX = math.sin(angle+math.radians(twist))*baseRadius + w_origin.X() + xOffset
+                baseY = math.cos(angle+math.radians(twist))*baseRadius + w_origin.Y() + yOffset
+                baseZ = w_origin.Z() + zOffset
                 baseV.append(Vertex.ByCoordinates(baseX,baseY,baseZ))
             if topRadius > 0:
-                topX = math.sin(angle-math.radians(twist))*topRadius + origin.X() + xOffset
-                topY = math.cos(angle-math.radians(twist))*topRadius + origin.Y() + yOffset
+                topX = math.sin(angle-math.radians(twist))*topRadius + w_origin.X() + xOffset
+                topY = math.cos(angle-math.radians(twist))*topRadius + w_origin.Y() + yOffset
                 topV.append(Vertex.ByCoordinates(topX,topY,topZ))
 
         hyperboloid = createHyperboloid(baseV, topV, tolerance)
         if hyperboloid == None:
             print("Cell.Hyperboloid - Error: Could not create a hyperboloid. Returning None.")
             return None
-        x1 = origin.X()
-        y1 = origin.Y()
-        z1 = origin.Z()
-        x2 = origin.X() + direction[0]
-        y2 = origin.Y() + direction[1]
-        z2 = origin.Z() + direction[2]
-        dx = x2 - x1
-        dy = y2 - y1
-        dz = z2 - z1    
-        dist = math.sqrt(dx**2 + dy**2 + dz**2)
-        phi = math.degrees(math.atan2(dy, dx)) # Rotation around Y-Axis
-        if dist < 0.0001:
-            theta = 0
-        else:
-            theta = math.degrees(math.acos(dz/dist)) # Rotation around Z-Axis
-        hyperboloid = Topology.Rotate(hyperboloid, origin, 0, 1, 0, theta)
-        hyperboloid = Topology.Rotate(hyperboloid, origin, 0, 0, 1, phi)
+        
+        hyperboloid = Topology.Orient(hyperboloid, origin=Vertex.Origin(), dirA=[0,0,1], dirB=direction, tolerance=tolerance)
+        hyperboloid = Topology.Place(hyperboloid, originA=Vertex.Origin(), originB=origin)
         return hyperboloid
     
     @staticmethod
@@ -1345,8 +1321,9 @@ class Cell(Topology):
             icosahedron = Topology.Translate(icosahedron, 0, 0, radius)
         elif placement == "lowerleft":
             icosahedron = Topology.Translate(icosahedron, radius, radius, radius)
+        
+        icosahedron = Topology.Orient(icosahedron, origin=Vertex.Origin(), dirA=[0,0,1], dirB=direction, tolerance=tolerance)
         icosahedron = Topology.Place(icosahedron, originA=Vertex.Origin(), originB=origin)
-        icosahedron = Topology.Orient(icosahedron, origin=origin, dirA=[0,0,1], dirB=direction, tolerance=tolerance)
         return icosahedron
 
 
@@ -1398,46 +1375,6 @@ class Cell(Topology):
             print("Cell.InternalVertex - Error: Could not create an internal vertex. Returning None.")
             return None
     
-    @staticmethod
-    def IsInside(cell: topologic.Cell, vertex: topologic.Vertex, tolerance: float = 0.0001) -> bool:
-        """
-        DEPRECATED METHOD. DO NOT USE. INSTEAD USE Cell.IsInternal.
-        """
-        print("Cell.IsInside - Warning: Deprecated method. This method will be removed in the future. Instead, use Cell.IsInternal.")
-        return Cell.IsInternal(cell=cell, vertex=vertex, tolerance=tolerance)
-    
-    @staticmethod
-    def IsInternal(cell: topologic.Cell, vertex: topologic.Vertex, tolerance: float = 0.0001) -> bool:
-        """
-        Returns True if the input vertex is an internal vertex of the input cell. Returns False otherwise.
-
-        Parameters
-        ----------
-        cell : topologic.Cell
-            The input cell.
-        vertex : topologic.Vertex
-            The input vertex.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
-
-        Returns
-        -------
-        bool
-            Returns True if the input vertex is inside the input cell. Returns False otherwise.
-
-        """
-        if not isinstance(cell, topologic.Cell):
-            print("Cell.IsInternal - Error: The input cell parameter is not a valid topologic cell. Returning None.")
-            return None
-        if not isinstance(vertex, topologic.Vertex):
-            print("Cell.IsInternal - Error: The input vertex parameter is not a valid topologic vertex. Returning None.")
-            return None
-        try:
-            return (topologic.CellUtility.Contains(cell, vertex, tolerance) == 0)
-        except:
-            print("Cell.IsInternal - Error: Could not determine if the input vertex is inside the input cell. Returning None.")
-            return None
-    
     @staticmethod
     def IsOnBoundary(cell: topologic.Cell, vertex: topologic.Vertex, tolerance: float = 0.0001) -> bool:
         """
@@ -1470,39 +1407,6 @@ class Cell(Topology):
         except:
             print("Cell.IsOnBoundary - Error: Could not determine if the input vertex is on the boundary of the input cell. Returning None.")
             return None
- 
-    @staticmethod
-    def IsOutside(cell: topologic.Cell, vertex: topologic.Vertex, tolerance: float = 0.0001) -> bool:
-        """
-        Returns True if the input vertex is outisde the input cell. Returns False otherwise.
-
-        Parameters
-        ----------
-        cell : topologic.Cell
-            The input cell.
-        vertex : topologic.Vertex
-            The input vertex.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
-
-        Returns
-        -------
-        bool
-            Returns True if the input vertex is inside the input cell. Returns False otherwise.
-
-        """
-
-        if not isinstance(cell, topologic.Cell):
-            print("Cell.IsOutside - Error: The input cell parameter is not a valid topologic cell. Returning None.")
-            return None
-        if not isinstance(vertex, topologic.Vertex):
-            print("Cell.IsOutside - Error: The input vertex parameter is not a valid topologic vertex. Returning None.")
-            return None
-        try:
-            return (topologic.CellUtility.Contains(cell, vertex, tolerance) == 2)
-        except:
-            print("Cell.IsOutside - Error: Could not determine if the input vertex is outside the input cell. Returning None.")
-            return None
     
     @staticmethod
     def Octahedron(origin: topologic.Vertex = None, radius: float = 0.5,
@@ -1563,8 +1467,8 @@ class Cell(Topology):
             octahedron = Topology.Translate(octahedron, 0, 0, radius)
         elif placement == "lowerleft":
             octahedron = Topology.Translate(octahedron, radius, radius, radius)
+        octahedron = Topology.Orient(octahedron, origin=Vertex.Origin(), dirA=[0,0,1], dirB=direction)
         octahedron = Topology.Place(octahedron, originA=Vertex.Origin(), originB=origin)
-        octahedron = Topology.Orient(octahedron, origin=origin, dirA=[0,0,1], dirB=direction)
         return octahedron
     
     @staticmethod
@@ -1873,6 +1777,8 @@ class Cell(Topology):
             The classified list of input cells based on their encolsure within the input list of super cells.
 
         """
+
+        from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
 
         if not isinstance(cells, list):
@@ -1907,7 +1813,7 @@ class Cell(Topology):
             if unused[i]:
                 iv = Topology.InternalVertex(cells[i], tolerance=tolerance)
                 for j in range(len(superCells)):
-                    if (Cell.IsInternal(superCells[j], iv, tolerance)):
+                    if (Vertex.IsInternal(iv, superCells[j], tolerance)):
                         sets[j].append(cells[i])
                         unused[i] = False
         return sets
@@ -1984,8 +1890,8 @@ class Cell(Topology):
             sphere = Topology.Translate(sphere, 0, 0, radius)
         elif placement.lower() == "lowerleft":
             sphere = Topology.Translate(sphere, radius, radius, radius)
+        sphere = Topology.Orient(sphere, origin=Vertex.Origin(), dirA=[0,0,1], dirB=direction)
         sphere = Topology.Place(sphere, originA=Vertex.Origin(), originB=origin)
-        sphere = Topology.Orient(sphere, origin=origin, dirA=[0,0,1], dirB=direction)
         return sphere
     
     @staticmethod
@@ -2117,8 +2023,8 @@ class Cell(Topology):
         elif placement.lower() == "lowerleft":
             torus = Topology.Translate(torus, majorRadius, majorRadius, minorRadius)
 
+        torus = Topology.Orient(torus, origin=Vertex.Origin(), dirA=[0,0,1], dirB=direction)
         torus = Topology.Place(torus, originA=Vertex.Origin(), originB=origin)
-        torus = Topology.Orient(torus, origin=origin, dirA=[0,0,1], dirB=direction)
         return torus
     
     @staticmethod

topologicpy/CellComplex.py

@@ -815,8 +815,8 @@ class CellComplex(Topology):
             octahedron = Topology.Translate(octahedron, 0, 0, radius)
         elif placement == "lowerleft":
             octahedron = Topology.Translate(octahedron, radius, radius, radius)
+        octahedron = Topology.Orient(octahedron, origin=Vertex.Origin(), dirA=[0,0,1], dirB=direction)
         octahedron = Topology.Place(octahedron, originA=Vertex.Origin(), originB=origin)
-        octahedron = Topology.Orient(octahedron, origin=origin, dirA=[0,0,1], dirB=direction)
         return octahedron
     
     @staticmethod
@@ -896,7 +896,7 @@ class CellComplex(Topology):
             for i in range(uSides-1):
                 uFaces.append(Topology.Translate(uFace, uOffset*(i+1),0,0))
             vOrigin = Vertex.ByCoordinates(Vertex.X(centroid), minY, Vertex.Z(centroid))
-            vFace = Face.Rectangle(origin=vOrigin, width=(maxZ-minZ)*1.1, length=(maxX-minX)*1.1, direction=[0,1,0])
+            vFace = Face.Rectangle(origin=vOrigin, width=(maxX-minX)*1.1, length=(maxZ-minZ)*1.1, direction=[0,1,0])
             vFaces = []
             vOffset = (maxY-minY)/vSides
             for i in range(vSides-1):
@@ -913,23 +913,7 @@ class CellComplex(Topology):
         c = Cell.Prism(origin=origin, width=width, length=length, height=height, uSides=1, vSides=1, wSides=1, placement=placement, tolerance=tolerance)
         prism = slice(c, uSides=uSides, vSides=vSides, wSides=wSides)
         if prism:
-            x1 = origin.X()
-            y1 = origin.Y()
-            z1 = origin.Z()
-            x2 = origin.X() + direction[0]
-            y2 = origin.Y() + direction[1]
-            z2 = origin.Z() + direction[2]
-            dx = x2 - x1
-            dy = y2 - y1
-            dz = z2 - z1    
-            dist = math.sqrt(dx**2 + dy**2 + dz**2)
-            phi = math.degrees(math.atan2(dy, dx)) # Rotation around Y-Axis
-            if dist < 0.0001:
-                theta = 0
-            else:
-                theta = math.degrees(math.acos(dz/dist)) # Rotation around Z-Axis
-            prism = Topology.Rotate(prism, origin, 0, 1, 0, theta)
-            prism = Topology.Rotate(prism, origin, 0, 0, 1, phi)
+            prism = Topology.Orient(prism, origin=origin, dirA=[0,0,1], dirB=direction)
             return prism
         else:
             print("CellComplex.Prism - Error: Could not create a prism. Returning None.")
@@ -1110,7 +1094,7 @@ class CellComplex(Topology):
                 vertices = Topology.Vertices(cell)
         else:
             vertices += Topology.Vertices(cell)
-        vertices = [v for v in vertices if (Cell.IsInternal(cell, v) or not Vertex.Index(v, Topology.Vertices(cell)) == None)]
+        vertices = [v for v in vertices if (Vertex.IsInternal(v, cell) or not Vertex.Index(v, Topology.Vertices(cell)) == None)]
         if len(vertices) < 1:
             print("CellComplex.Voronoi - Error: The input vertices parame ter does not contain any vertices that are inside the input cell parameter. Returning None.")
             return None

topologicpy/Cluster.py

@@ -135,7 +135,7 @@ class Cluster(Topology):
         return Cluster.ByTopologies(vertices)
     
     @staticmethod
-    def ByTopologies(*args) -> topologic.Cluster:
+    def ByTopologies(*args, transferDictionaries: bool = False) -> topologic.Cluster:
         """
         Creates a topologic Cluster from the input list of topologies. The input can be individual topologies each as an input argument or a list of topologies stored in one input argument.
 
@@ -143,6 +143,8 @@ class Cluster(Topology):
         ----------
         topologies : list
             The list of topologies.
+        transferDictionaries : bool , optional
+            If set to True, the dictionaries from the input topologies are merged and transferred to the cluster. Otherwise they are not. The default is False.
 
         Returns
         -------
@@ -150,8 +152,10 @@ class Cluster(Topology):
             The created topologic Cluster.
 
         """
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
         from topologicpy.Helper import Helper
-        #assert isinstance(topologies, list), "Cluster.ByTopologies - Error: Input is not a list"
+
         if len(args) == 0:
             print("Cluster.ByTopologies - Error: The input topologies parameter is an empty list. Returning None.")
             return None
@@ -175,7 +179,18 @@ class Cluster(Topology):
         if len(topologyList) == 0:
             print("Cluster.ByTopologies - Error: The input parameters do not contain any valid topologies. Returning None.")
             return None
-        return topologic.Cluster.ByTopologies(topologyList, False)
+        cluster = topologic.Cluster.ByTopologies(topologyList, False)
+        dictionaries = []
+        for t in topologyList:
+            d = Topology.Dictionary(t)
+            keys = Dictionary.Keys(d)
+            if isinstance(keys, list):
+                if len(keys) > 0:
+                    dictionaries.append(d)
+        if len(dictionaries) > 0:
+            d = Dictionary.ByMergedDictionaries(dictionaries)
+            cluster = Topology.SetDictionary(cluster, d)
+        return cluster
 
     @staticmethod
     def CellComplexes(cluster: topologic.Cluster) -> list:
@@ -740,6 +755,34 @@ class Cluster(Topology):
             return [] #Make sure you return an empty list instead of None
         return result
     
+    @staticmethod
+    def FreeTopologies(cluster: topologic.Cluster, tolerance: float = 0.0001) -> list:
+        """
+        Returns the free topologies of the input cluster that are not part of a higher topology.
+
+        Parameters
+        ----------
+        cluster : topologic.Cluster
+            The input cluster.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            The list of free topologies.
+
+        """
+        topologies = Cluster.FreeVertices(cluster, tolerance=tolerance)
+        topologies += Cluster.FreeEdges(cluster, tolerance=tolerance)
+        topologies += Cluster.FreeWires(cluster, tolerance=tolerance)
+        topologies += Cluster.FreeFaces(cluster, tolerance=tolerance)
+        topologies += Cluster.FreeShells(cluster, tolerance=tolerance)
+        topologies += Cluster.FreeCells(cluster, tolerance=tolerance)
+        topologies += Cluster.CellComplexes(cluster)
+
+        return topologies
+    
     @staticmethod
     def HighestType(cluster: topologic.Cluster) -> int:
         """

topologicpy/Edge.py

@@ -85,9 +85,12 @@ class Edge(Topology):
             The created bisecting edge.
 
         """
+        import numpy as np
+
         from topologicpy.Wire import Wire
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
+        from topologicpy.Vector import Vector
 
         if not isinstance(edgeA, topologic.Edge):
             print("Edge.Bisect - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
@@ -102,7 +105,7 @@ class Edge(Topology):
             print("Edge.Bisect - Error: The input edgeB parameter is shorter than the input tolerance parameter. Returning None.")
             return None
         
-        wire = Topology.SelfMerge(Cluster.ByTopologies([edgeA, edgeB]))
+        wire = Topology.SelfMerge(Cluster.ByTopologies([edgeA, edgeB]), tolerance=tolerance)
         if not isinstance(wire, topologic.Wire):
             print("Edge.Bisect - Error: The input edgeA and edgeB parameters do not share a vertex and thus cannot be bisected. Returning None.")
             return None
@@ -110,25 +113,14 @@ class Edge(Topology):
         edgeA = edges[0]
         edgeB = edges[1]
 
-        v1 = Edge.VertexByDistance(edgeA, -1, edgeA.EndVertex(), tolerance=0.0001)
-        newEdgeA = Edge.ByVertices([v1, edgeA.EndVertex()], tolerance=tolerance, silent=True)
-        v1 = Edge.VertexByDistance(edgeB, 1, edgeB.StartVertex(), tolerance=0.0001)
-        newEdgeB = Edge.ByVertices([edgeB.StartVertex(), v1], tolerance=tolerance, silent=True)
-        newEdgeB = Topology.Place(newEdgeB, newEdgeB.StartVertex(), newEdgeA.StartVertex())
-        bisectingEdge = Edge.ByVertices([newEdgeA.EndVertex(), newEdgeB.EndVertex()], tolerance=tolerance, silent=True)
-        bEdgeLength = Edge.Length(bisectingEdge)
-        bisectingEdge = Topology.Scale(bisectingEdge, bisectingEdge.StartVertex(), 1/bEdgeLength, 1/bEdgeLength, 1/bEdgeLength)
-        if length != 1.0 and length > tolerance:
-            bisectingEdge = Topology.Scale(bisectingEdge, bisectingEdge.StartVertex(), length, length, length)
-        newLocation = edgeA.EndVertex()
-        if placement == 2:
-            oldLocation = bisectingEdge.EndVertex()
-        elif placement == 1:
-            oldLocation = bisectingEdge.StartVertex()
-        else:
-            oldLocation = bisectingEdge.Centroid()
-        bisectingEdge = Topology.Place(bisectingEdge, oldLocation, newLocation)
-        return bisectingEdge
+        sv = Wire.Vertices(wire)[1]
+
+        dirA = Edge.Direction(edgeA)
+        dirB = Edge.Direction(edgeB)
+        bisecting_vector = Vector.Bisect(dirA, dirB)
+        ev = Topology.TranslateByDirectionDistance(sv, bisecting_vector, length)
+        bisecting_edge = Edge.ByVertices([sv, ev])
+        return bisecting_edge
 
     @staticmethod
     def ByFaceNormal(face: topologic.Face, origin: topologic.Vertex = None, length: float = 1.0, tolerance: float = 0.0001) -> topologic.Edge:
@@ -253,7 +245,7 @@ class Edge(Topology):
         return edge
     
     @staticmethod
-    def ByVertices(vertices: list, tolerance: float = 0.0001, silent: bool = False) -> topologic.Edge:
+    def ByVertices(*args, tolerance: float = 0.0001, silent: bool = False) -> topologic.Edge:
         """
         Creates a straight edge that connects the input list of vertices.
 
@@ -272,11 +264,32 @@ class Edge(Topology):
             The created edge.
 
         """
-        if not isinstance(vertices, list):
-            if not silent:
-                print("Edge.ByVertices - Error: The input vertices parameter is not a valid list. Returning None.")
+
+        from topologicpy.Helper import Helper
+
+        if len(args) == 0:
+            print("Edge.ByVertices - Error: The input vertices parameter is an empty list. Returning None.")
             return None
-        vertexList = [x for x in vertices if isinstance(x, topologic.Vertex)]
+        if len(args) == 1:
+            vertices = args[0]
+            if isinstance(vertices, list):
+                if len(vertices) == 0:
+                    if not silent:
+                        print("Edge.ByVertices - Error: The input vertices parameter is an empty list. Returning None.")
+                    return None
+                else:
+                    vertexList = [x for x in vertices if isinstance(x, topologic.Vertex)]
+                    if len(vertexList) == 0:
+                        if not silent:
+                            print("Edge.ByVertices - Error: The input vertices parameter does not contain any valid vertices. Returning None.")
+                        return None
+            else:
+                if not silent:
+                    print("Edge.ByVertices - Warning: The input vertices parameter contains only one vertex. Returning None.")
+                return None
+        else:
+            vertexList = Helper.Flatten(list(args))
+            vertexList = [x for x in vertexList if isinstance(x, topologic.Vertex)]
         if len(vertexList) < 2:
             if not silent:
                 print("Edge.ByVertices - Error: The input vertices parameter has less than two vertices. Returning None.")
@@ -436,7 +449,10 @@ class Edge(Topology):
             The extended edge.
 
         """
+
+        from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
+
         if not isinstance(edgeA, topologic.Edge):
             print("Edge.ExtendToEdge2D - Error: The input edgeA parameter is not a valid topologic edge. Returning None.")
             return None
@@ -446,7 +462,7 @@ class Edge(Topology):
         sva = Edge.StartVertex(edgeA)
         eva = Edge.EndVertex(edgeA)
         intVertex = Edge.Intersect2D(edgeA, edgeB)
-        if intVertex and not (Topology.IsInternal(edgeA, intVertex)):
+        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)
@@ -1058,7 +1074,7 @@ class Edge(Topology):
         sva = Edge.StartVertex(edgeA)
         eva = Edge.EndVertex(edgeA)
         intVertex = Edge.Intersect2D(edgeA, edgeB)
-        if intVertex and (Topology.IsInternal(edgeA, intVertex)):
+        if intVertex and (Vertex.IsInternal(intVertex, edgeA)):
             if reverse:
                 return Edge.ByVertices([eva, intVertex], tolerance=tolerance, silent=True)
             else: