topologicpy 0.7.4__py3-none-any.whl → 0.7.6__py3-none-any.whl

topologicpy/Cell.py

@@ -638,7 +638,7 @@ class Cell():
     
     @staticmethod
     def Cone(origin = None, baseRadius: float = 0.5, topRadius: float = 0, height: float = 1, uSides: int = 16, vSides: int = 1, direction: list = [0, 0, 1],
-                 dirZ: float = 1, placement: str = "center", tolerance: float = 0.0001):
+                 dirZ: float = 1, placement: str = "center", mantissa: int = 6, tolerance: float = 0.0001):
         """
         Creates a cone.
 
@@ -658,6 +658,8 @@ class Cell():
             The vector representing the up direction of the cone. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the cone. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -719,13 +721,13 @@ class Cell():
         for i in range(uSides):
             angle = math.radians(360/uSides)*i
             if baseRadius > 0:
-                baseX = math.cos(angle)*baseRadius + origin.X() + xOffset
-                baseY = math.sin(angle)*baseRadius + origin.Y() + yOffset
-                baseZ = origin.Z() + zOffset
+                baseX = math.cos(angle)*baseRadius + Vertex.X(origin, mantissa=mantissa) + xOffset
+                baseY = math.sin(angle)*baseRadius + Vertex.Y(origin, mantissa=mantissa) + yOffset
+                baseZ = Vertex.Z(origin, mantissa=mantissa) + zOffset
                 baseV.append(Vertex.ByCoordinates(baseX,baseY,baseZ))
             if topRadius > 0:
-                topX = math.cos(angle)*topRadius + origin.X() + xOffset
-                topY = math.sin(angle)*topRadius + origin.Y() + yOffset
+                topX = math.cos(angle)*topRadius + Vertex.X(origin, mantissa=mantissa) + xOffset
+                topY = math.sin(angle)*topRadius + Vertex.Y(origin, mantissa=mantissa) + yOffset
                 topV.append(Vertex.ByCoordinates(topX,topY,topZ))
         if baseRadius > 0:
             baseWire = Wire.ByVertices(baseV)
@@ -735,8 +737,8 @@ class Cell():
             topWire = Wire.ByVertices(topV)
         else:
             topWire = None
-        baseVertex = Vertex.ByCoordinates(origin.X()+xOffset, origin.Y()+yOffset, origin.Z()+zOffset)
-        topVertex = Vertex.ByCoordinates(origin.X()+xOffset, origin.Y()+yOffset, origin.Z()+zOffset+height)
+        baseVertex = Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa)+xOffset, Vertex.Y(origin, mantissa=mantissa)+yOffset, Vertex.Z(origin, mantissa=mantissa)+zOffset)
+        topVertex = Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa)+xOffset, Vertex.Y(origin, mantissa=mantissa)+yOffset, Vertex.Z(origin, mantissa=mantissa)+zOffset+height)
         cone = createCone(baseWire, topWire, baseVertex, topVertex, tolerance)
         if cone == None:
             print("Cell.Cone - Error: Could not create a cone. Returning None.")
@@ -744,11 +746,11 @@ class Cell():
         
         if vSides > 1:
             cutting_planes = []
-            baseX = origin.X() + xOffset
-            baseY = origin.Y() + yOffset
+            baseX = Vertex.X(origin, mantissa=mantissa) + xOffset
+            baseY = Vertex.Y(origin, mantissa=mantissa) + yOffset
             size = max(baseRadius, topRadius)*3
             for i in range(1, vSides):
-                baseZ = origin.Z() + zOffset + float(height)/float(vSides)*i
+                baseZ = Vertex.Z(origin, mantissa=mantissa) + zOffset + float(height)/float(vSides)*i
                 tool_origin = Vertex.ByCoordinates(baseX, baseY, baseZ)
                 cutting_planes.append(Face.ByWire(Wire.Rectangle(origin=tool_origin, width=size, length=size), tolerance=tolerance))
             cutting_planes_cluster = Cluster.ByTopologies(cutting_planes)
@@ -800,7 +802,7 @@ class Cell():
  
     @staticmethod
     def Cylinder(origin = None, radius: float = 0.5, height: float = 1, uSides: int = 16, vSides: int = 1, direction: list = [0, 0, 1],
-                     placement: str = "center", tolerance: float = 0.0001):
+                     placement: str = "center", mantissa: int = 6, tolerance: float = 0.0001):
         """
         Creates a cylinder.
 
@@ -820,6 +822,8 @@ class Cell():
             The vector representing the up direction of the cylinder. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the cylinder. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "bottom".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -848,7 +852,7 @@ class Cell():
         elif placement.lower() == "lowerleft":
             xOffset = radius
             yOffset = radius
-        circle_origin = Vertex.ByCoordinates(origin.X() + xOffset, origin.Y() + yOffset, origin.Z() + zOffset)
+        circle_origin = Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa) + xOffset, Vertex.Y(origin, mantissa=mantissa) + yOffset, Vertex.Z(origin, mantissa=mantissa) + zOffset)
         
         baseWire = Wire.Circle(origin=circle_origin, radius=radius, sides=uSides, fromAngle=0, toAngle=360, close=True, direction=[0, 0, 1], placement="center", tolerance=tolerance)
         baseFace = Face.ByWire(baseWire, tolerance=tolerance)
@@ -856,8 +860,8 @@ class Cell():
                             tolerance=tolerance)
         if vSides > 1:
             cutting_planes = []
-            baseX = origin.X() + xOffset
-            baseY = origin.Y() + yOffset
+            baseX = Vertex.X(origin, mantissa=mantissa) + xOffset
+            baseY = Vertex.Y(origin, mantissa=mantissa) + yOffset
             size = radius*3
             for i in range(1, vSides):
                 baseZ = origin.Z() + zOffset + float(height)/float(vSides)*i
@@ -1212,7 +1216,7 @@ class Cell():
 
     @staticmethod
     def Hyperboloid(origin = None, baseRadius: float = 0.5, topRadius: float = 0.5, height: float = 1, sides: int = 24, direction: list = [0, 0, 1],
-                        twist: float = 60, placement: str = "center", tolerance: float = 0.0001):
+                        twist: float = 60, placement: str = "center", mantissa: int = 6, tolerance: float = 0.0001):
         """
         Creates a hyperboloid.
 
@@ -1234,6 +1238,8 @@ class Cell():
             The angle to twist the base cylinder. The default is 60.
         placement : str , optional
             The description of the placement of the origin of the hyperboloid. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -1243,10 +1249,10 @@ class Cell():
             The created hyperboloid.
 
         """
-        from topologicpy.Cluster import Cluster
         from topologicpy.Vertex import Vertex
         from topologicpy.Wire import Wire
         from topologicpy.Face import Face
+        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         import math
 
@@ -1295,13 +1301,13 @@ class Cell():
         for i in range(sides):
             angle = math.radians(360/sides)*i
             if baseRadius > 0:
-                baseX = math.sin(angle+math.radians(twist))*baseRadius + w_origin.X() + xOffset
-                baseY = math.cos(angle+math.radians(twist))*baseRadius + w_origin.Y() + yOffset
-                baseZ = w_origin.Z() + zOffset
+                baseX = math.sin(angle+math.radians(twist))*baseRadius + Vertex.X(w_origin, mantissa=mantissa) + xOffset
+                baseY = math.cos(angle+math.radians(twist))*baseRadius + Vertex.Y(w_origin, mantissa=mantissa) + yOffset
+                baseZ = Vertex.Z(w_origin, mantissa=mantissa) + zOffset
                 baseV.append(Vertex.ByCoordinates(baseX,baseY,baseZ))
             if topRadius > 0:
-                topX = math.sin(angle-math.radians(twist))*topRadius + w_origin.X() + xOffset
-                topY = math.cos(angle-math.radians(twist))*topRadius + w_origin.Y() + yOffset
+                topX = math.sin(angle-math.radians(twist))*topRadius + Vertex.X(w_origin, mantissa=mantissa) + xOffset
+                topY = math.cos(angle-math.radians(twist))*topRadius + Vertex.Y(w_origin, mantissa=mantissa) + yOffset
                 topV.append(Vertex.ByCoordinates(topX,topY,topZ))
 
         hyperboloid = createHyperboloid(baseV, topV, tolerance)
@@ -1546,7 +1552,7 @@ class Cell():
         return octahedron
     
     @staticmethod
-    def Pipe(edge, profile = None, radius: float = 0.5, sides: int = 16, startOffset: float = 0, endOffset: float = 0, endcapA = None, endcapB = None) -> dict:
+    def Pipe(edge, profile = None, radius: float = 0.5, sides: int = 16, startOffset: float = 0, endOffset: float = 0, endcapA = None, endcapB = None, mantissa: int = 6) -> dict:
         """
         Description
         ----------
@@ -1570,7 +1576,9 @@ class Cell():
             The topology to place at the start vertex of the centerline edge. The positive Z direction of the end cap will be oriented in the direction of the centerline edge.
         endcapB, optional
             The topology to place at the end vertex of the centerline edge. The positive Z direction of the end cap will be oriented in the inverse direction of the centerline edge.
-
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6
+        
         Returns
         -------
         dict
@@ -1580,7 +1588,6 @@ class Cell():
             'endcapB'
 
         """
-
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
         from topologicpy.Wire import Wire
@@ -1596,12 +1603,12 @@ class Cell():
         endU = 1.0 - (endOffset / length)
         sv = Edge.VertexByParameter(edge, startU)
         ev = Edge.VertexByParameter(edge, endU)
-        x1 = sv.X()
-        y1 = sv.Y()
-        z1 = sv.Z()
-        x2 = ev.X()
-        y2 = ev.Y()
-        z2 = ev.Z()
+        x1 = Vertex.X(sv, mantissa=mantissa)
+        y1 = Vertex.Y(sv, mantissa=mantissa)
+        z1 = Vertex.Z(sv, mantissa=mantissa)
+        x2 = Vertex.X(ev, mantissa=mantissa)
+        y2 = Vertex.Y(ev, mantissa=mantissa)
+        z2 = Vertex.Z(ev, mantissa=mantissa)
         dx = x2 - x1
         dy = y2 - y1
         dz = z2 - z1
@@ -1615,9 +1622,9 @@ class Cell():
         else:
             for i in range(sides):
                 angle = math.radians(360/sides)*i
-                x = math.sin(angle)*radius + sv.X()
-                y = math.cos(angle)*radius + sv.Y()
-                z = sv.Z()
+                x = math.sin(angle)*radius + Vertex.X(sv, mantissa=mantissa)
+                y = math.cos(angle)*radius + Vertex.Y(sv, mantissa=mantissa)
+                z = Vertex.Z(sv, mantissa=mantissa)
                 baseV.append(Vertex.ByCoordinates(x, y, z))
                 topV.append(Vertex.ByCoordinates(x, y, z+dist))
 
@@ -1635,12 +1642,12 @@ class Cell():
         zzz = Vertex.ByCoordinates(0, 0, 0)
         if endcapA:
             origin = edge.StartVertex()
-            x1 = origin.X()
-            y1 = origin.Y()
-            z1 = origin.Z()
-            x2 = edge.EndVertex().X()
-            y2 = edge.EndVertex().Y()
-            z2 = edge.EndVertex().Z()
+            x1 = Vertex.X(origin, mantissa=mantissa)
+            y1 = Vertex.Y(origin, mantissa=mantissa)
+            z1 = Vertex.Z(origin, mantissa=mantissa)
+            x2 = Vertex.X(edge.EndVertex(), mantissa=mantissa)
+            y2 = Vertex.Y(edge.EndVertex(), mantissa=mantissa)
+            z2 = Vertex.Z(edge.EndVertex(), mantissa=mantissa)
             dx = x2 - x1
             dy = y2 - y1
             dz = z2 - z1    
@@ -1653,15 +1660,15 @@ class Cell():
             endcapA = Topology.Copy(endcapA)
             endcapA = Topology.Rotate(endcapA, origin=zzz, axis=[0, 1, 0], angle=theta)
             endcapA = Topology.Rotate(endcapA, origin=zzz, axis=[0, 0, 1], angle=phi+180)
-            endcapA = Topology.Translate(endcapA, origin.X(), origin.Y(), origin.Z())
+            endcapA = Topology.Translate(endcapA, Vertex.X(origin, mantissa=mantissa), Vertex.Y(origin, mantissa=mantissa), Vertex.Z(origin, mantissa=mantissa))
         if endcapB:
             origin = edge.EndVertex()
-            x1 = origin.X()
-            y1 = origin.Y()
-            z1 = origin.Z()
-            x2 = edge.StartVertex().X()
-            y2 = edge.StartVertex().Y()
-            z2 = edge.StartVertex().Z()
+            x1 = Vertex.X(origin, mantissa=mantissa)
+            y1 = Vertex.Y(origin, mantissa=mantissa)
+            z1 = Vertex.Z(origin, mantissa=mantissa)
+            x2 = Vertex.X(edge.StartVertex(), mantissa=mantissa)
+            y2 = Vertex.Y(edge.StartVertex(), mantissa=mantissa)
+            z2 = Vertex.Z(edge.StartVertex(), mantissa=mantissa)
             dx = x2 - x1
             dy = y2 - y1
             dz = z2 - z1    
@@ -1674,12 +1681,12 @@ class Cell():
             endcapB = Topology.Copy(endcapB)
             endcapB = Topology.Rotate(endcapB, origin=zzz, axis=[0, 1, 0], angle=theta)
             endcapB = Topology.Rotate(endcapB, origin=zzz, axis=[0, 0, 1], angle=phi+180)
-            endcapB = Topology.Translate(endcapB, origin.X(), origin.Y(), origin.Z())
+            endcapB = Topology.Translate(endcapB, Vertex.X(origin, mantissa=mantissa), Vertex.Y(origin, mantissa=mantissa), Vertex.Z(origin, mantissa=mantissa))
         return {'pipe': pipe, 'endcapA': endcapA, 'endcapB': endcapB}
     
     @staticmethod
     def Prism(origin= None, width: float = 1, length: float = 1, height: float = 1, uSides: int = 1, vSides: int = 1, wSides: int = 1,
-                  direction: list = [0, 0, 1], placement: str ="center", tolerance: float = 0.0001):
+                  direction: list = [0, 0, 1], placement: str ="center", mantissa: int = 6, tolerance: float = 0.0001):
         """
         Description
         ----------
@@ -1705,6 +1712,8 @@ class Cell():
             The vector representing the up direction of the prism. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the prism. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         
@@ -1755,10 +1764,10 @@ class Cell():
         elif placement.lower() == "lowerleft":
             xOffset = width*0.5
             yOffset = length*0.5
-        vb1 = Vertex.ByCoordinates(origin.X()-width*0.5+xOffset,origin.Y()-length*0.5+yOffset,origin.Z()+zOffset)
-        vb2 = Vertex.ByCoordinates(origin.X()+width*0.5+xOffset,origin.Y()-length*0.5+yOffset,origin.Z()+zOffset)
-        vb3 = Vertex.ByCoordinates(origin.X()+width*0.5+xOffset,origin.Y()+length*0.5+yOffset,origin.Z()+zOffset)
-        vb4 = Vertex.ByCoordinates(origin.X()-width*0.5+xOffset,origin.Y()+length*0.5+yOffset,origin.Z()+zOffset)
+        vb1 = Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa)-width*0.5+xOffset,Vertex.Y(origin, mantissa=mantissa)-length*0.5+yOffset,Vertex.Z(origin, mantissa=mantissa)+zOffset)
+        vb2 = Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa)+width*0.5+xOffset,Vertex.Y(origin, mantissa=mantissa)-length*0.5+yOffset,Vertex.Z(origin, mantissa=mantissa)+zOffset)
+        vb3 = Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa)+width*0.5+xOffset,Vertex.Y(origin, mantissa=mantissa)+length*0.5+yOffset,Vertex.Z(origin, mantissa=mantissa)+zOffset)
+        vb4 = Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa)-width*0.5+xOffset,Vertex.Y(origin, mantissa=mantissa)+length*0.5+yOffset,Vertex.Z(origin, mantissa=mantissa)+zOffset)
 
         baseWire = Wire.ByVertices([vb1, vb2, vb3, vb4], close=True)
         baseFace = Face.ByWire(baseWire, tolerance=tolerance)

topologicpy/CellComplex.py

@@ -831,7 +831,7 @@ class CellComplex():
     def Prism(origin= None,
               width: float = 1.0, length: float = 1.0, height: float = 1.0,
               uSides: int = 2, vSides: int = 2, wSides: int = 2,
-              direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
+              direction: list = [0, 0, 1], placement: str = "center", mantissa: int = 6, tolerance: float = 0.0001):
         """
         Creates a prismatic cellComplex with internal cells.
 
@@ -855,6 +855,8 @@ class CellComplex():
             The vector representing the up direction of the prism. The default is [0, 0, 1].
         placement : str , optional
             The description of the placement of the origin of the prism. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
         
@@ -876,9 +878,9 @@ class CellComplex():
             y = []
             z = []
             for aVertex in vertices:
-                x.append(aVertex.X())
-                y.append(aVertex.Y())
-                z.append(aVertex.Z())
+                x.append(Vertex.X(aVertex, mantissa=mantissa))
+                y.append(Vertex.Y(aVertex, mantissa=mantissa))
+                z.append(Vertex.Z(aVertex, mantissa=mantissa))
             minX = min(x)
             minY = min(y)
             minZ = min(z)
@@ -890,19 +892,19 @@ class CellComplex():
         def slice(topology, uSides, vSides, wSides):
             minX, minY, minZ, maxX, maxY, maxZ = bb(topology)
             centroid = Vertex.ByCoordinates(minX+(maxX-minX)*0.5, minY+(maxY-minY)*0.5, minZ+(maxZ-minZ)*0.5)
-            wOrigin = Vertex.ByCoordinates(Vertex.X(centroid), Vertex.Y(centroid), minZ)
+            wOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), Vertex.Y(centroid, mantissa=mantissa), minZ)
             wFace = Face.Rectangle(origin=wOrigin, width=(maxX-minX)*1.1, length=(maxY-minY)*1.1)
             wFaces = []
             wOffset = (maxZ-minZ)/wSides
             for i in range(wSides-1):
                 wFaces.append(Topology.Translate(wFace, 0,0,wOffset*(i+1)))
-            uOrigin = Vertex.ByCoordinates(minX, Vertex.Y(centroid), Vertex.Z(centroid))
+            uOrigin = Vertex.ByCoordinates(minX, Vertex.Y(centroid, mantissa=mantissa), Vertex.Z(centroid, mantissa=mantissa))
             uFace = Face.Rectangle(origin=uOrigin, width=(maxZ-minZ)*1.1, length=(maxY-minY)*1.1, direction=[1,0,0])
             uFaces = []
             uOffset = (maxX-minX)/uSides
             for i in range(uSides-1):
                 uFaces.append(Topology.Translate(uFace, uOffset*(i+1),0,0))
-            vOrigin = Vertex.ByCoordinates(Vertex.X(centroid), minY, Vertex.Z(centroid))
+            vOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), minY, Vertex.Z(centroid, mantissa=mantissa))
             vFace = Face.Rectangle(origin=vOrigin, width=(maxX-minX)*1.1, length=(maxZ-minZ)*1.1, direction=[0,1,0])
             vFaces = []
             vOffset = (maxY-minY)/vSides
@@ -917,7 +919,7 @@ class CellComplex():
         if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
 
-        c = Cell.Prism(origin=origin, width=width, length=length, height=height, uSides=1, vSides=1, wSides=1, placement=placement, tolerance=tolerance)
+        c = Cell.Prism(origin=origin, width=width, length=length, height=height, uSides=1, vSides=1, wSides=1, placement=placement, mantissa=mantissa, tolerance=tolerance)
         prism = slice(c, uSides=uSides, vSides=vSides, wSides=wSides)
         if prism:
             prism = Topology.Orient(prism, origin=origin, dirA=[0, 0, 1], dirB=direction)

topologicpy/Edge.py

@@ -348,6 +348,7 @@ class Edge():
             The direction of the input edge.
 
         """
+        from topologicpy.Vertex import Vertex
         from topologicpy.Vector import Vector
         from topologicpy.Topology import Topology
 
@@ -356,9 +357,9 @@ class Edge():
             return None
         ev = edge.EndVertex()
         sv = edge.StartVertex()
-        x = ev.X() - sv.X()
-        y = ev.Y() - sv.Y()
-        z = ev.Z() - sv.Z()
+        x = Vertex.X(ev, mantissa=mantissa) - Vertex.X(sv, mantissa=mantissa)
+        y = Vertex.Y(ev, mantissa=mantissa) - Vertex.Y(sv, mantissa=mantissa)
+        z = Vertex.Z(ev, mantissa=mantissa) - Vertex.Z(sv, mantissa=mantissa)
         uvec = Vector.Normalize([x,y,z])
         x = round(uvec[0], mantissa)
         y = round(uvec[1], mantissa)
@@ -538,7 +539,7 @@ class Edge():
         return None
 
     @staticmethod
-    def Intersect2D(edgeA, edgeB, silent: bool = False):
+    def Intersect2D(edgeA, edgeB, mantissa: int = 6, silent: bool = False):
         """
         Returns the intersection of the two input edges as a topologic_core.Vertex. This works only in the XY plane. Z coordinates are ignored.
 
@@ -548,6 +549,8 @@ class Edge():
             The first input edge.
         edgeB : topologic_core.Edge
             The second input edge.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         silent : bool , optional
             If set to False, error and warning messages are displayed. Otherwise they are not. The default is False.
 
@@ -573,14 +576,14 @@ class Edge():
         svb = Edge.StartVertex(edgeB)
         evb = Edge.EndVertex(edgeB)
         # Line AB represented as a1x + b1y = c1
-        a1 = Vertex.Y(eva) - Vertex.Y(sva)
-        b1 = Vertex.X(sva) - Vertex.X(eva)
-        c1 = a1*(Vertex.X(sva)) + b1*(Vertex.Y(sva))
+        a1 = Vertex.Y(eva, mantissa=mantissa) - Vertex.Y(sva, mantissa=mantissa)
+        b1 = Vertex.X(sva, mantissa=mantissa) - Vertex.X(eva, mantissa=mantissa)
+        c1 = a1*(Vertex.X(sva, mantissa=mantissa)) + b1*(Vertex.Y(sva, mantissa=mantissa))
  
         # Line CD represented as a2x + b2y = c2
-        a2 = Vertex.Y(evb) - Vertex.Y(svb)
-        b2 = Vertex.X(svb) - Vertex.X(evb)
-        c2 = a2*(Vertex.X(svb)) + b2*(Vertex.Y(svb))
+        a2 = Vertex.Y(evb, mantissa=mantissa) - Vertex.Y(svb, mantissa=mantissa)
+        b2 = Vertex.X(svb, mantissa=mantissa) - Vertex.X(evb, mantissa=mantissa)
+        c2 = a2*(Vertex.X(svb, mantissa=mantissa)) + b2*(Vertex.Y(svb, mantissa=mantissa))
  
         determinant = a1*b2 - a2*b1
  
@@ -639,7 +642,7 @@ class Edge():
         # Get start and end points of the first edge
         start_a = Edge.StartVertex(edgeA)
         end_a = Edge.EndVertex(edgeA)
-        start_a_coords = np.array([Vertex.X(start_a), Vertex.Y(start_a), Vertex.Z(start_a)])
+        start_a_coords = np.array([Vertex.X(start_a, mantissa=mantissa), Vertex.Y(start_a, mantissa=mantissa), Vertex.Z(start_a, mantissa=mantissa)])
         end_a_coords = np.array(
             [Vertex.X(end_a, mantissa=mantissa), Vertex.Y(end_a, mantissa=mantissa), Vertex.Z(end_a, mantissa=mantissa)])
 
@@ -1158,7 +1161,7 @@ class Edge():
         return edgeA
 
     @staticmethod
-    def VertexByDistance(edge, distance: float = 0.0, origin= None, tolerance: float = 0.0001):
+    def VertexByDistance(edge, distance: float = 0.0, origin= None, mantissa: int = 6, tolerance: float = 0.0001):
         """
         Creates a vertex along the input edge offset by the input distance from the input origin.
 
@@ -1170,6 +1173,8 @@ class Edge():
             The offset distance. The default is 0.
         origin : topologic_core.Vertex , optional
             The origin of the offset distance. If set to None, the origin will be set to the start vertex of the input edge. The default is None.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -1193,12 +1198,12 @@ class Edge():
             return None
         sv = edge.StartVertex()
         ev = edge.EndVertex()
-        vx = ev.X() - sv.X()
-        vy = ev.Y() - sv.Y()
-        vz = ev.Z() - sv.Z()
+        vx = Vertex.X(ev, mantissa=mantissa) - Vertex.X(sv, mantissa=mantissa)
+        vy = Vertex.Y(ev, mantissa=mantissa) - Vertex.Y(sv, mantissa=mantissa)
+        vz = Vertex.Z(ev, mantissa=mantissa) - Vertex.Z(sv, mantissa=mantissa)
         vector = Vector.Normalize([vx, vy, vz])
         vector = Vector.Multiply(vector, distance, tolerance)
-        return Vertex.ByCoordinates(origin.X()+vector[0], origin.Y()+vector[1], origin.Z()+vector[2])
+        return Vertex.ByCoordinates(Vertex.X(origin, mantissa=mantissa)+vector[0], Vertex.Y(origin, mantissa=mantissa)+vector[1], Vertex.Z(origin, mantissa=mantissa)+vector[2])
     
     @staticmethod
     def VertexByParameter(edge, u: float = 0.0):

topologicpy/EnergyModel.py

@@ -128,7 +128,9 @@ class EnergyModel:
                    heatingTemp : float = 20.0,
                    defaultSpaceType : str = "189.1-2009 - Office - WholeBuilding - Lg Office - CZ4-8",
                    spaceNameKey : str = "TOPOLOGIC_name",
-                   spaceTypeKey : str = "TOPOLOGIC_type"):
+                   spaceTypeKey : str = "TOPOLOGIC_type",
+                   mantissa : int = 6,
+                   tolerance : float = 0.0001):
         """
             Creates an EnergyModel from the input topology and parameters.
 
@@ -165,6 +167,10 @@ class EnergyModel:
             The dictionary key to use to find the space name value. The default is "Name".
         spaceTypeKey : str , optional
             The dictionary key to use to find the space type value. The default is "Type".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
 
         Returns
         -------
@@ -172,6 +178,7 @@ class EnergyModel:
             The created OSM model.
 
         """
+        from topologicpy.Vertex import Vertex
         from topologicpy.Face import Face
         from topologicpy.Cell import Cell
         from topologicpy.Topology import Topology
@@ -229,7 +236,7 @@ class EnergyModel:
                 hf = bhf+thf
             else:
                 return None
-            floorLevels = [Vertex.Z(Topology.Centroid(f)) for f in hf]
+            floorLevels = [Vertex.Z(Topology.Centroid(f), mantissa=mantissa) for f in hf]
             floorLevels = list(set(floorLevels))
             floorLevels.sort()
             return floorLevels
@@ -294,7 +301,7 @@ class EnergyModel:
             building_cells = [building]
         for spaceNumber, buildingCell in enumerate(building_cells):
             osSpace = openstudio.model.Space(osModel)
-            osSpaceZ = buildingCell.CenterOfMass().Z()
+            osSpaceZ = Vertex.Z(buildingCell.CenterOfMass(), mantissa=mantissa)
             osBuildingStory = osBuildingStorys[0]
             for x in osBuildingStorys:
                 osBuildingStoryZ = x.nominalZCoordinate().get()
@@ -344,9 +351,9 @@ class EnergyModel:
                 for faceNumber, buildingFace in enumerate(cellFaces):
                     osFacePoints = []
                     for vertex in Topology.SubTopologies(buildingFace.ExternalBoundary(), "Vertex"):
-                        osFacePoints.append(openstudio.Point3d(vertex.X(), vertex.Y(), vertex.Z()))
+                        osFacePoints.append(openstudio.Point3d(Vertex.X(vertex, mantissa=mantissa), Vertex.Y(vertex, mantissa=mantissa), Vertex.Z(vertex, mantissa=mantissa)))
                     osSurface = openstudio.model.Surface(osFacePoints, osModel)
-                    faceNormal = Face.Normal(buildingFace)
+                    faceNormal = Face.Normal(buildingFace, mantissa=mantissa)
                     osFaceNormal = openstudio.Vector3d(faceNormal[0], faceNormal[1], faceNormal[2])
                     osFaceNormal.normalize()
                     if osFaceNormal.dot(osSurface.outwardNormal()) < 1e-6:
@@ -376,9 +383,9 @@ class EnergyModel:
                                     osSubSurfacePoints = []
                                     apertureFace = Aperture.Topology(aperture)
                                     for vertex in Topology.SubTopologies(apertureFace.ExternalBoundary(), "Vertex"):
-                                        osSubSurfacePoints.append(openstudio.Point3d(vertex.X(), vertex.Y(), vertex.Z()))
+                                        osSubSurfacePoints.append(openstudio.Point3d(Vertex.X(vertex, mantissa=mantissa), Vertex.Y(vertex, mantissa=mantissa), Vertex.Z(vertex, mantissa=mantissa)))
                                     osSubSurface = openstudio.model.SubSurface(osSubSurfacePoints, osModel)
-                                    apertureFaceNormal = Face.Normal(apertureFace)
+                                    apertureFaceNormal = Face.Normal(apertureFace, mantissa=mantissa)
                                     osSubSurfaceNormal = openstudio.Vector3d(apertureFaceNormal[0], apertureFaceNormal[1], apertureFaceNormal[2])
                                     osSubSurfaceNormal.normalize()
                                     if osSubSurfaceNormal.dot(osSubSurface.outwardNormal()) < 1e-6:
@@ -414,9 +421,9 @@ class EnergyModel:
                                 osSubSurfacePoints = []
                                 apertureFace = Aperture.Topology(aperture)
                                 for vertex in Topology.SubTopologies(apertureFace.ExternalBoundary(), "Vertex"):
-                                    osSubSurfacePoints.append(openstudio.Point3d(vertex.X(), vertex.Y(), vertex.Z()))
+                                    osSubSurfacePoints.append(openstudio.Point3d(Vertex.X(vertex, mantissa=mantissa), Vertex.Y(vertex, mantissa=mantissa), Vertex.Z(vertex.Z, mantissa=mantissa)))
                                 osSubSurface = openstudio.model.SubSurface(osSubSurfacePoints, osModel)
-                                apertureFaceNormal = Face.Normal(apertureFace)
+                                apertureFaceNormal = Face.Normal(apertureFace, mantissa=mantissa)
                                 osSubSurfaceNormal = openstudio.Vector3d(apertureFaceNormal[0], apertureFaceNormal[1], apertureFaceNormal[2])
                                 osSubSurfaceNormal.normalize()
                                 if osSubSurfaceNormal.dot(osSubSurface.outwardNormal()) < 1e-6:
@@ -425,10 +432,10 @@ class EnergyModel:
                                 osSubSurface.setSurface(osSurface)
 
             osThermalZone = openstudio.model.ThermalZone(osModel)
-            osThermalZone.setVolume(Cell.Volume(buildingCell))
+            osThermalZone.setVolume(Cell.Volume(buildingCell, mantissa=mantissa))
             osThermalZone.setName(osSpace.name().get() + "_THERMAL_ZONE")
             osThermalZone.setUseIdealAirLoads(True)
-            osThermalZone.setVolume(Cell.Volume(buildingCell))
+            osThermalZone.setVolume(Cell.Volume(buildingCell, mantissa=mantissa))
             osThermalZone.setThermostatSetpointDualSetpoint(osThermostat)
             osSpace.setThermalZone(osThermalZone)
 
@@ -443,9 +450,9 @@ class EnergyModel:
             for faceIndex, shadingFace in enumerate(Topology.SubTopologies(shadingSurfaces, "Face")):
                 facePoints = []
                 for aVertex in Topology.SubTopologies(shadingFace.ExternalBoundary(), "Vertex"):
-                    facePoints.append(openstudio.Point3d(aVertex.X(), aVertex.Y(), aVertex.Z()))
+                    facePoints.append(openstudio.Point3d(Vertex.X(aVertex, mantissa=mantissa), Vertex.Y(aVertex, mantissa=mantissa), Vertex.Z(aVertex, mantissa=mantissa)))
                 aShadingSurface = openstudio.model.ShadingSurface(facePoints, osModel)
-                faceNormal = Face.Normal(shadingFace)
+                faceNormal = Face.Normal(shadingFace, mantissa=mantissa)
                 osFaceNormal = openstudio.Vector3d(faceNormal[0], faceNormal[1], faceNormal[2])
                 osFaceNormal.normalize()
                 if osFaceNormal.dot(aShadingSurface.outwardNormal()) < 0: