topologicpy 0.4.72__tar.gz → 0.4.73__tar.gz

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

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

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

{topologicpy-0.4.72 → 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
@@ -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-0.4.72 → topologicpy-0.4.73}/src/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,

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

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

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

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