topologicpy 0.4.71__tar.gz → 0.4.73__tar.gz

{topologicpy-0.4.71/src/topologicpy.egg-info → topologicpy-0.4.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.4.71
+Version: 0.4.73
 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.71 → topologicpy-0.4.73}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=61"]
 build-backend = "setuptools.build_meta"
 [project]
 name = "topologicpy"
-version = "0.4.71"
+version = "0.4.73"
 authors = [
   { name="Wassim Jabi", email="wassim.jabi@gmail.com" },
 ]

{topologicpy-0.4.71 → topologicpy-0.4.73}/src/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
@@ -933,6 +901,75 @@ class Cell(Topology):
             }
         return d
 
+    @staticmethod
+    def Dodecahedron(origin: topologic.Vertex = None, radius: float = 0.5,
+                  direction: list = [0,0,1], placement: str ="center", tolerance: float = 0.0001) -> topologic.Cell:
+        """
+        Description
+        ----------
+        Creates a dodecahedron. See https://en.wikipedia.org/wiki/Dodecahedron.
+
+        Parameters
+        ----------
+        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'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
+            The description of the placement of the origin of the dodecahedron. 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 dodecahedron.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Face import Face
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+
+        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
+        pen = Face.Circle(sides=5, radius=0.5)
+        pentagons = [pen]
+        edges = Topology.Edges(pen)
+        for edge in edges:
+            o = Topology.Centroid(edge)
+            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)
+        zList = [Vertex.Z(v) for v in vertices]
+        zList = list(set(zList))
+        zList.sort()
+        zOffset = zList[1]+zList[2]
+        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, tolerance=tolerance)
+        centroid = Topology.Centroid(dodecahedron)
+        dodecahedron = Topology.Translate(dodecahedron, -Vertex.X(centroid), -Vertex.Y(centroid), -Vertex.Z(centroid))
+        vertices = Topology.Vertices(dodecahedron)
+        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
     def Edges(cell: topologic.Cell) -> list:
         """
@@ -1119,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:
         """
@@ -1272,7 +1394,70 @@ class Cell(Topology):
         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,
+                  direction: list = [0,0,1], placement: str ="center", tolerance: float = 0.0001) -> topologic.Cell:
+        """
+        Description
+        ----------
+        Creates an octahedron. See https://en.wikipedia.org/wiki/Octahedron.
+
+        Parameters
+        ----------
+        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'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
+            The description of the placement of the origin of the octahedron. 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 octahedron.
+
+        """
+        
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Face import Face
+        from topologicpy.Topology import Topology
+
+        if not origin:
+            origin = Vertex.ByCoordinates(0,0,0)
+        if not isinstance(origin, topologic.Vertex):
+            print("Cell.Octahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
+            return None
+        
+        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])
+        f4 = Face.ByVertices([top,vb4,vb1])
+        f5 = Face.ByVertices([bottom,vb1,vb2])
+        f6 = Face.ByVertices([bottom,vb2,vb3])
+        f7 = Face.ByVertices([bottom,vb3,vb4])
+        f8 = Face.ByVertices([bottom,vb4,vb1])
+
+        octahedron = Cell.ByFaces([f1,f2,f3,f4,f5,f6,f7,f8], 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 Pipe(edge: topologic.Edge, profile: topologic.Wire = None, radius: float = 0.5, sides: int = 16, startOffset: float = 0, endOffset: float = 0, endcapA: topologic.Topology = None, endcapB: topologic.Topology = None) -> dict:
         """
@@ -1490,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
@@ -1695,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:
@@ -1743,7 +1897,67 @@ class Cell(Topology):
 
         """
         return Cell.Area(cell=cell, mantissa=mantissa)
+    
+    @staticmethod
+    def Tetrahedron(origin: topologic.Vertex = None, radius: float = 0.5,
+                  direction: list = [0,0,1], placement: str ="center", tolerance: float = 0.0001) -> topologic.Cell:
+        """
+        Description
+        ----------
+        Creates a tetrahedron. See https://en.wikipedia.org/wiki/Tetrahedron.
+
+        Parameters
+        ----------
+        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'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
+            The description of the placement of the origin of the tetrahedron. 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 tetrahedron.
+
+        """
+        
+        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.Tetrahedron - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
+            return None
+
+        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=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, radius, radius, radius)
+        elif placement.lower() == "bottom":
+            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
     def Torus(origin: topologic.Vertex = None, majorRadius: float = 0.5, minorRadius: float = 0.125, uSides: int = 16, vSides: int = 8, direction: list = [0,0,1], placement: str = "center", tolerance: float = 0.0001) -> topologic.Cell:
         """
@@ -1783,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-0.4.71 → topologicpy-0.4.73}/src/topologicpy/CellComplex.py

@@ -681,6 +681,70 @@ class CellComplex(Topology):
         _ = cellComplex.NonManifoldFaces(faces)
         return faces
     
+    @staticmethod
+    def Octahedron(origin: topologic.Vertex = None, radius: float = 0.5,
+                  direction: list = [0,0,1], placement: str ="center", tolerance: float = 0.0001) -> topologic.CellComplex:
+        """
+        Description
+        ----------
+        Creates an octahedron. See https://en.wikipedia.org/wiki/Octahedron.
+
+        Parameters
+        ----------
+        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'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
+            The description of the placement of the origin of the octahedron. 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.CellComplex
+            The created octahedron.
+
+        """
+        
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Face import Face
+        from topologicpy.Topology import 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.")
+            return None
+        
+        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])
+        f4 = Face.ByVertices([top,vb4,vb1])
+        f5 = Face.ByVertices([bottom,vb1,vb2])
+        f6 = Face.ByVertices([bottom,vb2,vb3])
+        f7 = Face.ByVertices([bottom,vb3,vb4])
+        f8 = Face.ByVertices([bottom,vb4,vb1])
+        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,

{topologicpy-0.4.71 → topologicpy-0.4.73}/src/topologicpy/Topology.py

@@ -3073,7 +3073,7 @@ class Topology():
             xT = newX - oldX
             yT = newY - oldY
             zT = newZ - oldZ
-            newTopology = Topology.Translate(aTopology, xT*300, yT, zT)
+            newTopology = Topology.Translate(aTopology, xT, yT, zT)
             newTopologies.append(newTopology)
         return Cluster.ByTopologies(newTopologies)
     

{topologicpy-0.4.71 → topologicpy-0.4.73}/src/topologicpy/__init__.py

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

{topologicpy-0.4.71 → topologicpy-0.4.73/src/topologicpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.4.71
+Version: 0.4.73
 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