topologicpy 0.4.72__py3-none-any.whl → 0.4.74__py3-none-any.whl

topologicpy/Cell.py

@@ -681,23 +681,7 @@ class Cell(Topology):
             shell = Cell.Shells(cone)[0]
             shell = shell.Slice(cutting_planes_cluster)
             cone = Cell.ByShell(shell)
-        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
-        cone = Topology.Rotate(cone, origin, 0, 1, 0, theta)
-        cone = Topology.Rotate(cone, origin, 0, 0, 1, phi)
+        cone = Topology.Orient(cone, origin=origin, dirA=[0,0,1], dirB=direction)
         return cone
   
     @staticmethod
@@ -805,23 +789,7 @@ class Cell(Topology):
             cutting_planes_cluster = Cluster.ByTopologies(cutting_planes)
             cylinder = CellComplex.ExternalBoundary(cylinder.Slice(cutting_planes_cluster))
 
-        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
-        cylinder = Topology.Rotate(cylinder, origin, 0, 1, 0, theta)
-        cylinder = Topology.Rotate(cylinder, origin, 0, 0, 1, phi)
+        cylinder = Topology.Orient(cylinder, origin=origin, dirA=[0,0,1], dirB=direction)
         return cylinder
     
     @staticmethod
@@ -946,7 +914,7 @@ class Cell(Topology):
         origin : topologic.Vertex , optional
             The origin location of the dodecahedron. The default is None which results in the dodecahedron being placed at (0,0,0).
         radius : float , optional
-            The radius of the dodecahedron. The default is 0.5.
+            The radius of the dodecahedron's circumscribed sphere. The default is 0.5.
         direction : list , optional
             The vector representing the up direction of the dodecahedron. The default is [0,0,1].
         placement : str , optional
@@ -976,8 +944,8 @@ class Cell(Topology):
         edges = Topology.Edges(pen)
         for edge in edges:
             o = Topology.Centroid(edge)
-            direction = Edge.Direction(edge)
-            pentagons.append(Topology.Rotate(pen, origin=o, x=direction[0], y=direction[1], z=direction[2], degree=116.565))
+            e_dir = Edge.Direction(edge)
+            pentagons.append(Topology.Rotate(pen, origin=o, x=e_dir[0], y=e_dir[1], z=e_dir[2], degree=116.565))
 
         cluster = Cluster.ByTopologies(pentagons)
         vertices = Topology.Vertices(cluster)
@@ -988,33 +956,18 @@ class Cell(Topology):
         cluster2 = Topology.Rotate(cluster, origin=Vertex.Origin(), x=1,y=0,z=0,degree=180)
         cluster2 = Topology.Translate(cluster2, 0, 0, zOffset)
         pentagons += Topology.Faces(cluster2)
-        dodecahedron = Cell.ByFaces(pentagons)
+        dodecahedron = Cell.ByFaces(pentagons, tolerance=tolerance)
         centroid = Topology.Centroid(dodecahedron)
         dodecahedron = Topology.Translate(dodecahedron, -Vertex.X(centroid), -Vertex.Y(centroid), -Vertex.Z(centroid))
         vertices = Topology.Vertices(dodecahedron)
-        centroid = Topology.Centroid(dodecahedron)
-        d = Vertex.Distance(centroid, vertices[0])
-        p = Cell.Prism(origin=origin, width=radius*2, length=radius*2, height=radius*2)
-        s = Cell.Sphere(origin=origin, radius=radius)
-        dodecahedron = Topology.Scale(dodecahedron, origin=centroid, x=radius/d, y=radius/d, z=radius/d)
-        dodecahedron = Topology.Translate(dodecahedron, Vertex.X(origin), Vertex.Y(origin), Vertex.Z(origin))
-        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
-        dodecahedron = Topology.Rotate(dodecahedron, origin, 0, 1, 0, theta)
-        dodecahedron = Topology.Rotate(dodecahedron, origin, 0, 0, 1, phi)
+        d = Vertex.Distance(Vertex.Origin(), vertices[0])
+        dodecahedron = Topology.Scale(dodecahedron, origin=Vertex.Origin(), x=radius/d, y=radius/d, z=radius/d)
+        if placement == "bottom":
+            dodecahedron = Topology.Translate(dodecahedron, 0, 0, radius)
+        elif placement == "lowerleft":
+            dodecahedron = Topology.Translate(dodecahedron, radius, radius, radius)
+        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
@@ -1203,6 +1156,91 @@ class Cell(Topology):
         hyperboloid = Topology.Rotate(hyperboloid, origin, 0, 0, 1, phi)
         return hyperboloid
     
+    @staticmethod
+    def Icosahedron(origin: topologic.Vertex = None, radius: float = 0.5,
+                  direction: list = [0,0,1], placement: str ="center", tolerance: float = 0.0001) -> topologic.Cell:
+        """
+        Description
+        ----------
+        Creates an icosahedron. See https://en.wikipedia.org/wiki/Icosahedron.
+
+        Parameters
+        ----------
+        origin : topologic.Vertex , optional
+            The origin location of the icosahedron. The default is None which results in the icosahedron being placed at (0,0,0).
+        radius : float , optional
+            The radius of the icosahedron's circumscribed sphere. The default is 0.5.
+        direction : list , optional
+            The vector representing the up direction of the icosahedron. The default is [0,0,1].
+        placement : str , optional
+            The description of the placement of the origin of the icosahedron. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        
+        Returns
+        -------
+        topologic.Cell
+            The created icosahedron.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Topology import Topology
+        import math
+
+        if not origin:
+            origin = Vertex.ByCoordinates(0,0,0)
+        if not isinstance(origin, topologic.Vertex):
+            print("Cell.Dodecahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
+            return None
+        rect1 = Wire.Rectangle(width=(1+math.sqrt(5))/2, length=1)
+        rect2 = Wire.Rectangle(width=1, length=(1+math.sqrt(5))/2)
+        rect2 = Topology.Rotate(rect2, x=1,y=0,z=0, degree=90)
+        rect3 = Wire.Rectangle(width=1, length=(1+math.sqrt(5))/2)
+        rect3 = Topology.Rotate(rect3, x=0,y=1,z=0, degree=90)
+        vertices = Topology.Vertices(rect1)
+        v1, v2, v3, v4 = vertices
+        vertices = Topology.Vertices(rect2)
+        v5, v6, v7, v8 = vertices
+        vertices = Topology.Vertices(rect3)
+        v9, v10, v11, v12 = vertices
+        f1 = Face.ByVertices([v1,v8,v4])
+        f2 = Face.ByVertices([v1,v4,v5])
+        f3 = Face.ByVertices([v3,v2,v6])
+        f4 = Face.ByVertices([v2,v3,v7])
+        f5 = Face.ByVertices([v10,v9,v2])
+        f6 = Face.ByVertices([v10,v9,v1])
+        f7 = Face.ByVertices([v12,v11,v4])
+        f8 = Face.ByVertices([v12,v11,v3])
+        f9 = Face.ByVertices([v8,v7,v9])
+        f10 = Face.ByVertices([v8,v7,v12])
+        f11 = Face.ByVertices([v5,v6,v10])
+        f12 = Face.ByVertices([v5,v6,v11])
+        f13 = Face.ByVertices([v8,v1,v9])
+        f14 = Face.ByVertices([v9,v2,v7])
+        f15 = Face.ByVertices([v7,v3,v12])
+        f16 = Face.ByVertices([v8,v12,v4])
+        f17 = Face.ByVertices([v1,v5,v10])
+        f18 = Face.ByVertices([v10,v2,v6])
+        f19 = Face.ByVertices([v6,v3,v11])
+        f20 = Face.ByVertices([v11,v4,v5])
+
+        icosahedron = Cell.ByFaces([f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,
+                        f11,f12,f13,f14,f15,f16,f17,f18,f19,f20], tolerance=tolerance)
+        sf = 1.051*0.5 # To insribe it in a sphere of radius 0.5
+        icosahedron = Topology.Scale(icosahedron, origin=Vertex.Origin(), x=sf, y=sf, z=sf)
+        sf = radius/0.5
+        icosahedron = Topology.Scale(icosahedron, origin=Vertex.Origin(), x=sf, y=sf, z=sf)
+        if placement == "bottom":
+            icosahedron = Topology.Translate(icosahedron, 0, 0, radius)
+        elif placement == "lowerleft":
+            icosahedron = Topology.Translate(icosahedron, radius, radius, radius)
+        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
+
+
     @staticmethod
     def InternalBoundaries(cell: topologic.Cell) -> list:
         """
@@ -1370,7 +1408,7 @@ class Cell(Topology):
         origin : topologic.Vertex , optional
             The origin location of the octahedron. The default is None which results in the octahedron being placed at (0,0,0).
         radius : float , optional
-            The radius of the octahedron. The default is 0.5.
+            The radius of the octahedron's circumscribed sphere. The default is 0.5.
         direction : list , optional
             The vector representing the up direction of the octahedron. The default is [0,0,1].
         placement : str , optional
@@ -1392,25 +1430,15 @@ class Cell(Topology):
         if not origin:
             origin = Vertex.ByCoordinates(0,0,0)
         if not isinstance(origin, topologic.Vertex):
-            print("CellComplex.Octahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
+            print("Cell.Octahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
             return None
-        xOffset = 0
-        yOffset = 0
-        zOffset = 0
-        if placement.lower() == "center":
-            zOffset = 0
-        elif placement.lower() == "lowerleft":
-            xOffset = radius/math.sqrt(2)
-            yOffset = radius/math.sqrt(2)
-            zOffset = radius
-        elif placement.lower() == "bottom":
-            zOffset = radius
-        vb1 = Vertex.ByCoordinates(origin.X()-radius/math.sqrt(2)+xOffset,origin.Y()-radius/math.sqrt(2)+yOffset,origin.Z()+zOffset)
-        vb2 = Vertex.ByCoordinates(origin.X()+radius/math.sqrt(2)+xOffset,origin.Y()-radius/math.sqrt(2)+yOffset,origin.Z()+zOffset)
-        vb3 = Vertex.ByCoordinates(origin.X()+radius/math.sqrt(2)+xOffset,origin.Y()+radius/math.sqrt(2)+yOffset,origin.Z()+zOffset)
-        vb4 = Vertex.ByCoordinates(origin.X()-radius/math.sqrt(2)+xOffset,origin.Y()+radius/math.sqrt(2)+yOffset,origin.Z()+zOffset)
-        top = Vertex.ByCoordinates(origin.X()+xOffset, origin.Y()+yOffset, origin.Z()+radius+zOffset)
-        bottom = Vertex.ByCoordinates(origin.X()+xOffset, origin.Y()+yOffset, origin.Z()-radius+zOffset)
+        
+        vb1 = Vertex.ByCoordinates(-0.5,0,0)
+        vb2 = Vertex.ByCoordinates(0,-0.5,0)
+        vb3 = Vertex.ByCoordinates(0.5,0,0)
+        vb4 = Vertex.ByCoordinates(0,0.5,0)
+        top = Vertex.ByCoordinates(0, 0, 0.5)
+        bottom = Vertex.ByCoordinates(0, 0, -0.5)
         f1 = Face.ByVertices([top,vb1,vb2])
         f2 = Face.ByVertices([top,vb2,vb3])
         f3 = Face.ByVertices([top,vb3,vb4])
@@ -1421,24 +1449,13 @@ class Cell(Topology):
         f8 = Face.ByVertices([bottom,vb4,vb1])
 
         octahedron = Cell.ByFaces([f1,f2,f3,f4,f5,f6,f7,f8], tolerance=tolerance)
-
-        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
-        octahedron = Topology.Rotate(octahedron, origin, 0, 1, 0, theta)
-        octahedron = Topology.Rotate(octahedron, origin, 0, 0, 1, phi)
+        octahedron = Topology.Scale(octahedron, origin=Vertex.Origin(), x=radius/0.5, y=radius/0.5, z=radius/0.5)
+        if placement == "bottom":
+            octahedron = Topology.Translate(octahedron, 0, 0, radius)
+        elif placement == "lowerleft":
+            octahedron = Topology.Translate(octahedron, radius, radius, radius)
+        octahedron = Topology.Place(octahedron, originA=Vertex.Origin(), originB=origin)
+        octahedron = Topology.Orient(octahedron, origin=origin, dirA=[0,0,1], dirB=direction)
         return octahedron
     
     @staticmethod
@@ -1658,23 +1675,7 @@ class Cell(Topology):
 
         if uSides > 1 or vSides > 1 or wSides > 1:
             prism = sliceCell(prism, width, length, height, uSides, vSides, wSides)
-        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, tolerance=tolerance)
         return prism
 
     @staticmethod
@@ -1863,34 +1864,19 @@ class Cell(Topology):
         if not isinstance(origin, topologic.Vertex):
             print("Cell.Sphere - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
             return None
-        c = Wire.Circle(origin=origin, radius=radius, sides=vSides, fromAngle=90, toAngle=270, close=False, direction=[0, 1, 0], placement="center")
-        s = Topology.Spin(c, origin=origin, triangulate=False, direction=[0,0,1], degree=360, sides=uSides, tolerance=tolerance)
-        if s.Type() == topologic.CellComplex.Type():
-            s = s.ExternalBoundary()
-        if s.Type() == topologic.Shell.Type():
-            s = topologic.Cell.ByShell(s)
+        c = Wire.Circle(origin=Vertex.Origin(), radius=radius, sides=vSides, fromAngle=90, toAngle=270, close=False, direction=[0, 1, 0], placement="center")
+        sphere = Topology.Spin(c, origin=Vertex.Origin(), triangulate=False, direction=[0,0,1], degree=360, sides=uSides, tolerance=tolerance)
+        if sphere.Type() == topologic.CellComplex.Type():
+            sphere = sphere.ExternalBoundary()
+        if sphere.Type() == topologic.Shell.Type():
+            sphere = topologic.Cell.ByShell(sphere)
         if placement.lower() == "bottom":
-            s = Topology.Translate(s, 0, 0, radius)
+            sphere = Topology.Translate(sphere, 0, 0, radius)
         elif placement.lower() == "lowerleft":
-            s = Topology.Translate(s, radius, radius, radius)
-        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
-        s = Topology.Rotate(s, origin, 0, 1, 0, theta)
-        s = Topology.Rotate(s, origin, 0, 0, 1, phi)
-        return s
+            sphere = Topology.Translate(sphere, radius, radius, radius)
+        sphere = Topology.Place(sphere, originA=Vertex.Origin(), originB=origin)
+        sphere = Topology.Orient(sphere, origin=origin, dirA=[0,0,1], dirB=direction)
+        return sphere
     
     @staticmethod
     def SurfaceArea(cell: topologic.Cell, mantissa: int = 6) -> float:
@@ -1925,7 +1911,7 @@ class Cell(Topology):
         origin : topologic.Vertex , optional
             The origin location of the tetrahedron. The default is None which results in the tetrahedron being placed at (0,0,0).
         radius : float , optional
-            The radius of the tetrahedron. The default is 0.5.
+            The radius of the tetrahedron's circumscribed sphere. The default is 0.5.
         direction : list , optional
             The vector representing the up direction of the tetrahedron. The default is [0,0,1].
         placement : str , optional
@@ -1941,6 +1927,7 @@ class Cell(Topology):
         """
         
         from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
         from topologicpy.Face import Face
         from topologicpy.Topology import Topology
         import math
@@ -1950,50 +1937,25 @@ class Cell(Topology):
         if not isinstance(origin, topologic.Vertex):
             print("Cell.Tetrahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
             return None
-        xOffset = 0
-        yOffset = 0
-        zOffset = 0
-        if placement.lower() == "center":
-            zOffset = 0
-        elif placement.lower() == "lowerleft":
-            xOffset = radius*0.5
-            yOffset = radius*0.5
-            zOffset = radius*0.5
-        elif placement.lower() == "bottom":
-            zOffset = radius*0.5
-        vb1 = Vertex.ByCoordinates(origin.X()+math.sqrt(8/9)*0.5, origin.Y(), origin.Z()-1/6)
-        vb2 = Vertex.ByCoordinates(origin.X()-math.sqrt(2/9)*0.5, origin.Y()+math.sqrt(2/3)*0.5, origin.Z()-1/6)
-        vb3 = Vertex.ByCoordinates(origin.X()-math.sqrt(2/9)*0.5, origin.Y()-math.sqrt(2/3)*0.5, origin.Z()-1/6)
-        vb4 = Vertex.ByCoordinates(origin.X(),origin.Y(),origin.Z()+0.5)
+
+        vb1 = Vertex.ByCoordinates(math.sqrt(8/9), 0, -1/3)
+        vb2 = Vertex.ByCoordinates(-math.sqrt(2/9), math.sqrt(2/3), -1/3)
+        vb3 = Vertex.ByCoordinates(-math.sqrt(2/9), -math.sqrt(2/3), -1/3)
+        vb4 = Vertex.ByCoordinates(0,0,1)
         f1 = Face.ByVertices([vb1,vb2,vb3])
         f2 = Face.ByVertices([vb4,vb1,vb2])
         f3 = Face.ByVertices([vb4,vb2,vb3])
         f4 = Face.ByVertices([vb4,vb3,vb1])
-
         tetrahedron = Cell.ByFaces([f1,f2,f3,f4])
-        tetrahedron = Topology.Scale(tetrahedron, origin=origin, x=radius*2, y=radius*2, z=radius*2)
+        tetrahedron = Topology.Scale(tetrahedron, origin=Vertex.Origin(), x=0.5, y=0.5, z=0.5)
+        tetrahedron = Topology.Scale(tetrahedron, origin=Vertex.Origin(), x=radius/0.5, y=radius/0.5, z=radius/0.5)
+
         if placement.lower() == "lowerleft":
-            tetrahedron = Topology.Translate(tetrahedron, math.sqrt(2/9)*radius, math.sqrt(2/3)*radius, 1/3*radius)
+            tetrahedron = Topology.Translate(tetrahedron, radius, radius, radius)
         elif placement.lower() == "bottom":
-            tetrahedron = Topology.Translate(tetrahedron, 0, 0, 1/3*radius)
-
-        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
-        tetrahedron = Topology.Rotate(tetrahedron, origin, 0, 1, 0, theta)
-        tetrahedron = Topology.Rotate(tetrahedron, origin, 0, 0, 1, phi)
+            tetrahedron = Topology.Translate(tetrahedron, 0, 0, radius)
+        tetrahedron = Topology.Place(tetrahedron, originA=Vertex.Origin(), originB=origin)
+        tetrahedron = Topology.Orient(tetrahedron, origin=origin, dirA=[0,0,1], dirB=direction, tolerance=tolerance)
         return tetrahedron
     
     @staticmethod
@@ -2035,33 +1997,19 @@ class Cell(Topology):
         if not isinstance(origin, topologic.Vertex):
             print("Cell.Torus - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
             return None
-        c = Wire.Circle(origin=origin, radius=minorRadius, sides=vSides, fromAngle=0, toAngle=360, close=False, direction=[0, 1, 0], placement="center")
+        c = Wire.Circle(origin=Vertex.Origin(), radius=minorRadius, sides=vSides, fromAngle=0, toAngle=360, close=False, direction=[0, 1, 0], placement="center")
         c = Topology.Translate(c, abs(majorRadius-minorRadius), 0, 0)
-        s = Topology.Spin(c, origin=origin, triangulate=False, direction=[0,0,1], degree=360, sides=uSides, tolerance=tolerance)
-        if s.Type() == topologic.Shell.Type():
-            s = topologic.Cell.ByShell(s)
+        torus = Topology.Spin(c, origin=Vertex.Origin(), triangulate=False, direction=[0,0,1], degree=360, sides=uSides, tolerance=tolerance)
+        if torus.Type() == topologic.Shell.Type():
+            torus = topologic.Cell.ByShell(torus)
         if placement.lower() == "bottom":
-            s = Topology.Translate(s, 0, 0, majorRadius)
+            torus = Topology.Translate(torus, 0, 0, minorRadius)
         elif placement.lower() == "lowerleft":
-            s = Topology.Translate(s, majorRadius, majorRadius, minorRadius)
-        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
-        s = Topology.Rotate(s, origin, 0, 1, 0, theta)
-        s = Topology.Rotate(s, origin, 0, 0, 1, phi)
-        return s
+            torus = Topology.Translate(torus, majorRadius, majorRadius, minorRadius)
+
+        torus = Topology.Place(torus, originA=Vertex.Origin(), originB=origin)
+        torus = Topology.Orient(torus, origin=origin, dirA=[0,0,1], dirB=direction)
+        return torus
     
     @staticmethod
     def Vertices(cell: topologic.Cell) -> list:

topologicpy/CellComplex.py

@@ -694,7 +694,7 @@ class CellComplex(Topology):
         origin : topologic.Vertex , optional
             The origin location of the octahedron. The default is None which results in the octahedron being placed at (0,0,0).
         radius : float , optional
-            The radius of the octahedron. The default is 1.
+            The radius of the octahedron's circumscribed sphere. The default is 0.5.
         direction : list , optional
             The vector representing the up direction of the octahedron. The default is [0,0,1].
         placement : str , optional
@@ -705,7 +705,7 @@ class CellComplex(Topology):
         Returns
         -------
         topologic.CellComplex
-            The created octahedron. The octahedron will have two cells in it.
+            The created octahedron.
 
         """
         
@@ -718,24 +718,13 @@ class CellComplex(Topology):
         if not isinstance(origin, topologic.Vertex):
             print("CellComplex.Octahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
             return None
-        xOffset = 0
-        yOffset = 0
-        zOffset = 0
-        if placement.lower() == "center":
-            zOffset = 0
-        elif placement.lower() == "lowerleft":
-            xOffset = radius/math.sqrt(2)
-            yOffset = radius/math.sqrt(2)
-            zOffset = radius
-        elif placement.lower() == "bottom":
-            zOffset = radius
-        vb1 = Vertex.ByCoordinates(origin.X()-radius/math.sqrt(2)+xOffset,origin.Y()-radius/math.sqrt(2)+yOffset,origin.Z()+zOffset)
-        vb2 = Vertex.ByCoordinates(origin.X()+radius/math.sqrt(2)+xOffset,origin.Y()-radius/math.sqrt(2)+yOffset,origin.Z()+zOffset)
-        vb3 = Vertex.ByCoordinates(origin.X()+radius/math.sqrt(2)+xOffset,origin.Y()+radius/math.sqrt(2)+yOffset,origin.Z()+zOffset)
-        vb4 = Vertex.ByCoordinates(origin.X()-radius/math.sqrt(2)+xOffset,origin.Y()+radius/math.sqrt(2)+yOffset,origin.Z()+zOffset)
-        top = Vertex.ByCoordinates(origin.X()+xOffset, origin.Y()+yOffset, origin.Z()+radius+zOffset)
-        bottom = Vertex.ByCoordinates(origin.X()+xOffset, origin.Y()+yOffset, origin.Z()-radius+zOffset)
-        f0 = Face.ByVertices([vb1,vb2,vb3,vb4])
+        
+        vb1 = Vertex.ByCoordinates(-0.5,0,0)
+        vb2 = Vertex.ByCoordinates(0,-0.5,0)
+        vb3 = Vertex.ByCoordinates(0.5,0,0)
+        vb4 = Vertex.ByCoordinates(0,0.5,0)
+        top = Vertex.ByCoordinates(0, 0, 0.5)
+        bottom = Vertex.ByCoordinates(0, 0, -0.5)
         f1 = Face.ByVertices([top,vb1,vb2])
         f2 = Face.ByVertices([top,vb2,vb3])
         f3 = Face.ByVertices([top,vb3,vb4])
@@ -744,27 +733,18 @@ class CellComplex(Topology):
         f6 = Face.ByVertices([bottom,vb2,vb3])
         f7 = Face.ByVertices([bottom,vb3,vb4])
         f8 = Face.ByVertices([bottom,vb4,vb1])
-
-        octahedron = CellComplex.ByFaces([f0,f1,f2,f3,f4,f5,f6,f7,f8], tolerance=tolerance)
-
-        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
-        octahedron = Topology.Rotate(octahedron, origin, 0, 1, 0, theta)
-        octahedron = Topology.Rotate(octahedron, origin, 0, 0, 1, phi)
+        f9 = Face.ByVertices([vb1,vb2,vb3,vb4])
+
+        octahedron = CellComplex.ByFaces([f1,f2,f3,f4,f5,f6,f7,f8,f9], tolerance=tolerance)
+        octahedron = Topology.Scale(octahedron, origin=Vertex.Origin(), x=radius/0.5, y=radius/0.5, z=radius/0.5)
+        if placement == "bottom":
+            octahedron = Topology.Translate(octahedron, 0, 0, radius)
+        elif placement == "lowerleft":
+            octahedron = Topology.Translate(octahedron, radius, radius, radius)
+        octahedron = Topology.Place(octahedron, originA=Vertex.Origin(), originB=origin)
+        octahedron = Topology.Orient(octahedron, origin=origin, dirA=[0,0,1], dirB=direction)
         return octahedron
+    
     @staticmethod
     def Prism(origin: topologic.Vertex = None,
               width: float = 1.0, length: float = 1.0, height: float = 1.0,
@@ -987,7 +967,73 @@ class CellComplex(Topology):
             if not volume == None:
                 volume += Cell.Volume(cell)
         return round(volume, mantissa)
+    
+    @staticmethod
+    def Voronoi(vertices: list, cell: topologic.Cell = None, tolerance: float = 0.0001):
+        """
+        Partitions the input cell based on the Voronoi method. See https://en.wikipedia.org/wiki/Voronoi_diagram.
+
+        Parameters
+        ----------
+        vertices: list
+            The input list of vertices to use for voronoi partitioning.
+        cell : topologic.Cell , optional
+            The input cell. If set to None, an axes-aligned bounding cell is created from the list of vertices. The default is None.
+        tolerance : float , optional
+            the desired tolerance. The default is 0.0001.
+        
+
+        Returns
+        -------
+        float
+            The volume of the input cellComplex.
 
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+        from scipy.spatial import Voronoi as SCIVoronoi
+        import numpy as np
+
+        def fracture_with_voronoi(points):
+            # Compute Voronoi tessellation
+            vor = SCIVoronoi(points)
+            verts = []
+            faces = []
+            for v in vor.vertices:
+                verts.append(Vertex.ByCoordinates(list(v)))
+            for region in vor.ridge_vertices:
+                temp_list = []
+                if -1 not in region and len(region) > 0:
+                    for item in region:
+                        temp_list.append(verts[item])
+                    f = Face.ByVertices(temp_list)
+                    if isinstance(f, topologic.Face):
+                        faces.append(f)
+            return Cluster.ByTopologies(faces)
+        
+
+        if cell == None:
+            cell = Topology.BoundingBox(Cluster.ByTopologies(vertices))
+        if not isinstance(cell, topologic.Cell):
+            print("CellComplex.Voronoi - Error: The input cell parameter is not a valid cell. Returning None.")
+            return None
+        vertices = [v for v in vertices if Cell.IsInternal(cell, v)]
+        if len(vertices) < 1:
+            print("CellComplex.Voronoi - Error: The input vertices paramter does not contain any vertices that are inside the input cell parameter. Returning None.")
+            return None
+        cell_vertices = Topology.Vertices(cell)
+        all_vertices = cell_vertices + vertices
+        voronoi_points = np.array([Vertex.Coordinates(v) for v in all_vertices])
+        cluster = fracture_with_voronoi(voronoi_points)
+        cellComplex = Topology.Slice(cell, cluster)
+        if not isinstance(cellComplex, topologic.CellComplex):
+            print("CellComplex.Voronoi - Error: the operation failed. Returning None.")
+            return None
+        return cellComplex
+    
     @staticmethod
     def Wires(cellComplex: topologic.CellComplex) -> list:
         """

topologicpy/__init__.py

@@ -18,7 +18,7 @@ import sys
 import os, re
 from sys import platform
 
-__version__ = '0.4.72'
+__version__ = '0.4.74'
 __version_info__ = tuple([ int(num) for num in __version__.split('.')])
 
 if platform == 'win32':

{topologicpy-0.4.72.dist-info → topologicpy-0.4.74.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.4.72
+Version: 0.4.74
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 Project-URL: Homepage, https://github.com/wassimj/TopologicPy

{topologicpy-0.4.72.dist-info → topologicpy-0.4.74.dist-info}/RECORD

@@ -1,6 +1,6 @@
 topologicpy/Aperture.py,sha256=vENYlFaM6Pu-xCJB1YsW1I1_u5yDj-A70aU3bo3lpFA,2819
-topologicpy/Cell.py,sha256=abzxCHHuo16X-8B-R48z0XHMDBLS5dWayZucz_pEZXo,93859
-topologicpy/CellComplex.py,sha256=OSDDMi7IZkGrNYhDJu7AOuF0fw5B5mBbJr7gS32t2xo,41950
+topologicpy/Cell.py,sha256=91vG1L65RjBFSZZ9GA9ZCXUyCY60No9SLQvEeX17mhY,93138
+topologicpy/CellComplex.py,sha256=63k_5FBlMJDZUD5xtYiAGl2-azqcZ_vNVNL7-RUoMK0,43855
 topologicpy/Cluster.py,sha256=AVKUayG0wCAEWTI_aLE7i0CvllpaVDEsU7Z_PgAQ1M8,52831
 topologicpy/Color.py,sha256=8G7dI0CKNMPwhL0658LfmUJt-Ud-6o7xfem_laoi9vQ,10473
 topologicpy/Context.py,sha256=bgwslZSu8Ijuz3fusdhP6XcDnCdwGhtbI0-uhVjB36U,2977
@@ -23,7 +23,7 @@ topologicpy/Topology.py,sha256=zjGBxnVvlx8-7EARFgnIpD49nVfdDAyYKoHuABWHLgU,28614
 topologicpy/Vector.py,sha256=g28SO3yggTfYfpGqjE-dXpk1loQb9ZaZvP12B7Fzdcw,19564
 topologicpy/Vertex.py,sha256=A7hCI-WpHaemow4eDiaqVhZ0ekgifXcWFpa-82txwYM,55187
 topologicpy/Wire.py,sha256=gMqOqNOmph2Elup6j8bNrorBZfCScVChjTvq03rB6NA,133812
-topologicpy/__init__.py,sha256=Vq7GyqYi-OukYE_eppUwm7wthZd---mD7aQl8h2woc4,1445
+topologicpy/__init__.py,sha256=xPdxZJULDEpfOS3-Tcde50M9q_83JNmpE9PDAL5jskI,1445
 topologicpy/bin/linux/topologic/__init__.py,sha256=XlFReDf3FWlYdM9uXtanYPIafgPb6GVTQczS_xJAXD0,60
 topologicpy/bin/linux/topologic/libTKBO-6bdf205d.so.7.7.0,sha256=ANok9DQKcnWcLd9T_LAt-i-X4nsYYy16q9kQlcTre1E,2996488
 topologicpy/bin/linux/topologic/libTKBRep-2960a069.so.7.7.0,sha256=OJ3XesL79du8LeBHrsleGPXub6OpJdOilxha0mwjqQo,1378768
@@ -84,8 +84,8 @@ topologicpy/bin/windows/topologic/topologic.cp310-win_amd64.pyd,sha256=F0sPLuMpD
 topologicpy/bin/windows/topologic/topologic.cp311-win_amd64.pyd,sha256=aBAJQj3OmJ58MOAF1ZIFybL_5fFK7FNR9hrIps6b6pc,1551872
 topologicpy/bin/windows/topologic/topologic.cp38-win_amd64.pyd,sha256=aLgNf54nbJmGc7Tdmkuy-V0m6B9zLxabIbpRwAy7cBA,1551360
 topologicpy/bin/windows/topologic/topologic.cp39-win_amd64.pyd,sha256=_8cp205hiRxkFHtzQQOweA4DhCPk8caH4kTVLWGQeVw,1411584
-topologicpy-0.4.72.dist-info/LICENSE,sha256=RUmXeeqj63bBySLJjEfhwb9OE7M8h9K6HuOBF3ASVyI,35697
-topologicpy-0.4.72.dist-info/METADATA,sha256=NOQFFDiCAydc1gnzvk7uYXl5sBD9nuGa5FHcPkSHohc,7252
-topologicpy-0.4.72.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-topologicpy-0.4.72.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.4.72.dist-info/RECORD,,
+topologicpy-0.4.74.dist-info/LICENSE,sha256=RUmXeeqj63bBySLJjEfhwb9OE7M8h9K6HuOBF3ASVyI,35697
+topologicpy-0.4.74.dist-info/METADATA,sha256=YZCjMT3etplLdrUJSbpexAWKR8Ns7_JIt_s-6PgJct0,7252
+topologicpy-0.4.74.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+topologicpy-0.4.74.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.4.74.dist-info/RECORD,,