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

topologicpy/Face.py

@@ -942,7 +942,7 @@ class Face():
         return eb
     
     @staticmethod
-    def FacingToward(face, direction: list = [0,0,-1], asVertex: bool = False, tolerance: float = 0.0001) -> bool:
+    def FacingToward(face, direction: list = [0,0,-1], asVertex: bool = False, mantissa: int = 6, tolerance: float = 0.0001) -> bool:
         """
         Returns True if the input face is facing toward the input direction.
 
@@ -954,6 +954,8 @@ class Face():
             The input direction. The default is [0,0,-1].
         asVertex : bool , optional
             If set to True, the direction is treated as an actual vertex in 3D space. The default is False.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -963,22 +965,16 @@ class Face():
             True if the face is facing toward the direction. False otherwise.
 
         """
+        from topologicpy.Vertex import Vertex
         from topologicpy.Vector import Vector
 
-        faceNormal = Face.Normal(face)
+        faceNormal = Face.Normal(face, mantissa=mantissa)
         faceCenter = Face.VertexByParameters(face,0.5,0.5)
-        cList = [faceCenter.X(), faceCenter.Y(), faceCenter.Z()]
-        try:
-            vList = [direction.X(), direction.Y(), direction.Z()]
-        except:
-            try:
-                vList = [direction[0], direction[1], direction[2]]
-            except:
-                raise Exception("Face.FacingToward - Error: Could not get the vector from the input direction")
+        cList = [Vertex.X(faceCenter, mantissa=mantissa), Vertex.Y(faceCenter, mantissa=mantissa), Vertex.Z(faceCenter, mantissa=mantissa)]
         if asVertex:
-            dV = [vList[0]-cList[0], vList[1]-cList[1], vList[2]-cList[2]]
+            dV = [direction[0]-cList[0], direction[1]-cList[1], direction[2]-cList[2]]
         else:
-            dV = vList
+            dV = direction
         uV = Vector.Normalize(dV)
         dot = sum([i*j for (i, j) in zip(uV, faceNormal)])
         if dot < tolerance:
@@ -1322,9 +1318,10 @@ class Face():
         max_d = distances[-1]*1.05
         edges = []
         for target in targets:
-            e = Edge.ByVertices(vertex, target)
-            e = Edge.SetLength(e, length=max_d, bothSides=False)
-            edges.append(e)
+            if Vertex.Distance(vertex, target) > tolerance:
+                e = Edge.ByVertices(vertex, target)
+                e = Edge.SetLength(e, length=max_d, bothSides=False)
+                edges.append(e)
         shell = Topology.Slice(face, Cluster.ByTopologies(edges))
         faces = Topology.Faces(shell)
         final_faces = []
@@ -1987,7 +1984,7 @@ class Face():
         return Face.ByWire(wire, tolerance=tolerance)
 
     @staticmethod
-    def Triangulate(face, mode: int = 0, meshSize: float = None, tolerance: float = 0.0001) -> list:
+    def Triangulate(face, mode: int = 0, meshSize: float = None, mantissa: int = 6, tolerance: float = 0.0001) -> list:
         """
         Triangulates the input face and returns a list of faces.
 
@@ -1995,8 +1992,6 @@ class Face():
         ----------
         face : topologic_core.Face
             The input face.
-        tolerance : float , optional
-            The desired tolerance. The default is 0.0001.
         mode : int , optional
             The desired mode of meshing algorithm. Several options are available:
             0: Classic
@@ -2012,6 +2007,10 @@ class Face():
         meshSize : float , optional
             The desired size of the mesh when using the "mesh" option. If set to None, it will be
             calculated automatically and set to 10% of the overall size of the face.
+        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
         -------
@@ -2073,7 +2072,6 @@ class Face():
                     warnings.warn("Face.Triangulate - Error: Could not import gmsh. Please try to install gmsh manually. Returning None.")
                     return None
 
-            import topologic_core as topologic
             from topologicpy.Vertex import Vertex
             from topologicpy.Wire import Wire
             from topologicpy.Face import Face
@@ -2084,8 +2082,8 @@ class Face():
             if not meshSize:
                 bounding_face = Face.BoundingRectangle(face)
                 bounding_face_vertices = Face.Vertices(bounding_face)
-                bounding_face_vertices_x = [Vertex.X(i) for i in bounding_face_vertices]
-                bounding_face_vertices_y = [Vertex.Y(i) for i in bounding_face_vertices]
+                bounding_face_vertices_x = [Vertex.X(i, mantissa=mantissa) for i in bounding_face_vertices]
+                bounding_face_vertices_y = [Vertex.Y(i, mantissa=mantissa) for i in bounding_face_vertices]
                 width = max(bounding_face_vertices_x)-min(bounding_face_vertices_x)
                 length = max(bounding_face_vertices_y)-min(bounding_face_vertices_y)
                 meshSize = max([width,length])//10
@@ -2095,7 +2093,7 @@ class Face():
             external_vertices = Wire.Vertices(face_external_boundary)
             external_vertex_number = len(external_vertices)
             for i in range(external_vertex_number):
-                gmsh.model.geo.addPoint(Vertex.X(external_vertices[i]), Vertex.Y(external_vertices[i]), Vertex.Z(external_vertices[i]), meshSize, i+1)
+                gmsh.model.geo.addPoint(Vertex.X(external_vertices[i], mantissa=mantissa), Vertex.Y(external_vertices[i], mantissa=mantissa), Vertex.Z(external_vertices[i], mantissa=mantissa), meshSize, i+1)
             for i in range(external_vertex_number):
                 if i < external_vertex_number-1:
                     gmsh.model.geo.addLine(i+1, i+2, i+1)
@@ -2114,7 +2112,7 @@ class Face():
                     internal_vertices = Wire.Vertices(face_internal_boundary)
                     internal_vertex_number = len(internal_vertices)
                     for j in range(internal_vertex_number):
-                        gmsh.model.geo.addPoint(Vertex.X(internal_vertices[j]), Vertex.Y(internal_vertices[j]), Vertex.Z(internal_vertices[j]), meshSize, current_vertex_number+j+1)
+                        gmsh.model.geo.addPoint(Vertex.X(internal_vertices[j]), Vertex.Y(internal_vertices[j], mantissa=mantissa), Vertex.Z(internal_vertices[j], mantissa=mantissa), meshSize, current_vertex_number+j+1)
                     for j in range(internal_vertex_number):
                         if j < internal_vertex_number-1:
                             gmsh.model.geo.addLine(current_vertex_number+j+1, current_vertex_number+j+2, current_edge_number+j+1)
@@ -2160,7 +2158,7 @@ class Face():
         if len(vertices) == 3: # Already a triangle
             return [face]
         origin = Topology.Centroid(face)
-        normal = Face.Normal(face)
+        normal = Face.Normal(face, mantissa=mantissa)
         flatFace = Topology.Flatten(face, origin=origin, direction=normal)
 
         if mode == 0:
@@ -2179,7 +2177,7 @@ class Face():
         finalFaces = []
         for f in shell_faces:
             f = Topology.Unflatten(f, origin=origin, direction=normal)
-            if Face.Angle(face, f) > 90:
+            if Face.Angle(face, f, mantissa=mantissa) > 90:
                 wire = Face.ExternalBoundary(f)
                 wire = Wire.Invert(wire)
                 f = Face.ByWire(wire)

topologicpy/Graph.py

@@ -62,8 +62,6 @@ except:
     except:
         warnings.warn("Graph - Error: Could not import tqdm.")
 
-
-
 class _Tree:
     def __init__(self, node="", *children):
         self.node = node
@@ -94,7 +92,6 @@ class _Tree:
         return len(self.children)
 
 
-
 class _DrawTree(object):
     def __init__(self, tree, parent=None, depth=0, number=1):
         self.x = -1.0
@@ -557,7 +554,8 @@ class Graph:
                 slabType = "slab",
                 doorType = "door",
                 windowType = "window",
-                contentType = "content"
+                contentType = "content",
+                namespace = "http://github.com/wassimj/topologicpy/resources"
                 ):
         """
         Creates an RDF graph according to the BOT ontology. See https://w3c-lbd-cg.github.io/bot/.
@@ -621,7 +619,7 @@ class Graph:
         try:
             from rdflib import Graph as RDFGraph
             from rdflib import URIRef, Literal, Namespace
-            from rdflib.namespace import RDF, RDFS
+            from rdflib.namespace import RDF, RDFS, XSD
         except:
             print("Graph.BOTGraph - Information: Installing required rdflib library.")
             try:
@@ -646,9 +644,12 @@ class Graph:
         # Define namespaces
         rdf = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
         bot = Namespace("https://w3id.org/bot#")
+        top = Namespace(namespace)
         
         # Define a custom prefix mapping
         bot_graph.namespace_manager.bind("bot", bot)
+        bot_graph.namespace_manager.bind("xsd", XSD)
+        bot_graph.namespace_manager.bind("top", top)
         
         # Add site
         site_uri = URIRef(siteLabel)
@@ -705,7 +706,7 @@ class Graph:
         
         # Add vertices as RDF resources
         for node, attributes in json_data['vertices'].items():
-            node_uri = URIRef(node)
+            node_uri = URIRef(top[node])
             if spaceType.lower() in attributes[typeKey].lower():
                 bot_graph.add((node_uri, rdf.type, bot.Space))
                 # Find the storey it is on
@@ -730,6 +731,8 @@ class Graph:
             
             if includeAttributes:
                 for key, value in attributes.items():
+                    if key == "brepType":
+                        print("Key = brepType, Value =", value, value.__class__)
                     if key == geometryKey:
                         if includeGeometry:
                             bot_graph.add((node_uri, bot.hasSimpleGeometry, Literal(value)))
@@ -737,7 +740,17 @@ class Graph:
                         if includeLabel:
                             bot_graph.add((node_uri, RDFS.label, Literal(value)))
                     elif key != typeKey and key != geometryKey:
-                        bot_graph.add((node_uri, bot[key], Literal(value)))
+                        if isinstance(value, float):
+                            datatype = XSD.float
+                        elif isinstance(value, bool):
+                            print("got boolean")
+                            datatype = XSD.boolean
+                        elif isinstance(value, int):
+                            print("got integer")
+                            datatype = XSD.integer
+                        elif isinstance(value, str):
+                            datatype = XSD.string
+                        bot_graph.add((node_uri, top[key], Literal(value, datatype=datatype)))
             if includeLabel:
                 for key, value in attributes.items():
                     if key == labelKey:
@@ -747,8 +760,8 @@ class Graph:
         for edge, attributes in json_data['edges'].items():
             source = attributes["source"]
             target = attributes["target"]
-            source_uri = URIRef(source)
-            target_uri = URIRef(target)
+            source_uri = URIRef(top[source])
+            target_uri = URIRef(top[target])
             if spaceType.lower() in json_data['vertices'][source][typeKey].lower() and spaceType.lower() in json_data['vertices'][target][typeKey].lower():
                 bot_graph.add((source_uri, bot.adjacentTo, target_uri))
                 if bidirectional:
@@ -4347,6 +4360,7 @@ class Graph:
     def ExportToBOT(graph,
                     path,
                     format="turtle",
+                    namespace = "http://github.com/wassimj/topologicpy/resources",
                     overwrite = False,
                     bidirectional=False,
                     includeAttributes=False,
@@ -4386,6 +4400,8 @@ class Graph:
             trig : Trig , Turtle-like format for RDF triples + context (RDF quads) and thus multiple graphs
             trix : Trix , RDF/XML-like format for RDF quads
             nquads : N-Quads , N-Triples-like format for RDF quads
+        namespace : str , optional
+            The desired namespace for creating IRIs for entities. The default is "http://github.com/wassimj/topologicpy/resources".
         path : str
             The desired path to where the RDF/BOT file will be saved.
         overwrite : bool , optional
@@ -4465,7 +4481,8 @@ class Graph:
                             slabType = slabType,
                             doorType = doorType,
                             windowType = windowType,
-                            contentType = contentType
+                            contentType = contentType,
+                            namespace = namespace
                             )
         if "turtle" in format.lower() or "ttl" in format.lower() or "turtle2" in format.lower():
             ext = ".ttl"
@@ -4759,7 +4776,7 @@ class Graph:
                     node_features = node_features + ","+ str(round(float(Dictionary.ValueAtKey(nd, node_feature_key)),mantissa))
                 else:
                     node_features = str(round(float(Dictionary.ValueAtKey(nd, node_feature_key)),mantissa))
-            single_node_data = [graph_id, i, vLabel, train_mask, validate_mask, test_mask, node_features, round(float(Vertex.X(v)),mantissa), round(float(Vertex.Y(v)),mantissa), round(float(Vertex.Z(v)),mantissa)]
+            single_node_data = [graph_id, i, vLabel, train_mask, validate_mask, test_mask, node_features, float(Vertex.X(v, mantissa=mantissa)), float(Vertex.Y(v,mantissa)), float(Vertex.Z(v,mantissa))]
             node_data.append(single_node_data)
 
         # Write Node Data to CSV file
@@ -4871,11 +4888,11 @@ class Graph:
         return True
     
     @staticmethod
-    def ExportToGEXF(graph, path, graphWidth=20, graphLength=20, graphHeight=20,
-                    defaultVertexColor="black", defaultVertexSize=3,
-                    vertexLabelKey=None, vertexColorKey=None, vertexSizeKey=None, 
-                    defaultEdgeColor="black", defaultEdgeWeight=1, defaultEdgeType="undirected",
-                    edgeLabelKey=None, edgeColorKey=None, edgeWeightKey=None, overwrite=False):
+    def ExportToGEXF(graph, path: str = None, graphWidth: float = 20, graphLength: float = 20, graphHeight: float = 20,
+                    defaultVertexColor: str = "black", defaultVertexSize: float = 3,
+                    vertexLabelKey: str = None, vertexColorKey: str = None, vertexSizeKey: str = None, 
+                    defaultEdgeColor: str = "black", defaultEdgeWeight: float = 1, defaultEdgeType: str = "undirected",
+                    edgeLabelKey: str = None, edgeColorKey: str = None, edgeWeightKey: str = None, overwrite: bool = False, mantissa: int = 6):
         """
         Exports the input graph to a Graph Exchange XML (GEXF) file format. See https://gexf.net/
 
@@ -4921,6 +4938,8 @@ class Graph:
             the edge weight is set to the value defined by defaultEdgeWeight parameter. The default is None.
         overwrite : bool , optional
             If set to True, any existing file is overwritten. Otherwise, it is not. The default is False.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
 
         Returns
         -------
@@ -5049,9 +5068,9 @@ class Graph:
                         'size': 'double'}
         nodes = {}
         # Resize the graph
-        xList = [Vertex.X(v) for v in g_vertices]
-        yList = [Vertex.Y(v) for v in g_vertices]
-        zList = [Vertex.Z(v) for v in g_vertices]
+        xList = [Vertex.X(v, mantissa=mantissa) for v in g_vertices]
+        yList = [Vertex.Y(v, mantissa=mantissa) for v in g_vertices]
+        zList = [Vertex.Z(v, mantissa=mantissa) for v in g_vertices]
         xMin = min(xList)
         xMax = max(xList)
         yMin = min(yList)
@@ -5073,9 +5092,9 @@ class Graph:
             d = Topology.Dictionary(v)
             keys = Dictionary.Keys(d)
             values = Dictionary.Values(d)
-            x = (Vertex.X(v) - x_avg)*x_sf + x_avg
-            y = (Vertex.Y(v) - y_avg)*y_sf + y_avg
-            z = (Vertex.Z(v) - z_avg)*z_sf + z_avg
+            x = (Vertex.X(v, mantissa=mantissa) - x_avg)*x_sf + x_avg
+            y = (Vertex.Y(v, mantissa=mantissa) - y_avg)*y_sf + y_avg
+            z = (Vertex.Z(v, mantissa=mantissa) - z_avg)*z_sf + z_avg
             node_dict['x'] = x
             node_dict['y'] = y
             node_dict['z'] = z
@@ -5944,17 +5963,17 @@ class Graph:
     
     @staticmethod
     def JSONData(graph,
-                 verticesKey="vertices",
-                 edgesKey="edges",
-                 vertexLabelKey="",
-                 edgeLabelKey="",
-                 sourceKey="source",
-                 targetKey="target",
-                 xKey="x",
-                 yKey="y",
-                 zKey="z",
-                 geometryKey="brep",
-                 mantissa=6):
+                 verticesKey: str = "vertices",
+                 edgesKey: str = "edges",
+                 vertexLabelKey: str = "",
+                 edgeLabelKey: str = "",
+                 sourceKey: str = "source",
+                 targetKey: str = "target",
+                 xKey: str = "x",
+                 yKey: str = "y",
+                 zKey: str = "z",
+                 geometryKey: str = "brep",
+                 mantissa: int = 6):
         """
         Converts the input graph into JSON data.
 
@@ -5975,7 +5994,7 @@ class Graph:
         sourceKey : str , optional
             The dictionary key used to store the source vertex. The default is "source".
         targetKey : str , optional
-            The dictionary key used to store the target vertex. The default is "source".
+            The dictionary key used to store the target vertex. The default is "target".
         xKey : str , optional
             The desired key name to use for x-coordinates. The default is "x".
         yKey : str , optional
@@ -6709,7 +6728,7 @@ class Graph:
         return nearestVertex
 
     @staticmethod
-    def NetworkXGraph(graph, tolerance=0.0001):
+    def NetworkXGraph(graph, mantissa: int = 6, tolerance: float = 0.0001):
         """
         converts the input graph into a NetworkX Graph. See http://networkx.org
 
@@ -6717,6 +6736,10 @@ class Graph:
         ----------
         graph : topologic_core.Graph
             The input graph.
+        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
         -------
@@ -6763,7 +6786,7 @@ class Graph:
                     values = []
                 keys += ["x","y","z"]
                 import random
-                values += [Vertex.X(v), Vertex.Y(v), Vertex.Z(v)]
+                values += [Vertex.X(v, mantissa=mantissa), Vertex.Y(v, mantissa=mantissa), Vertex.Z(v, mantissa=mantissa)]
                 d = Dictionary.ByKeysValues(keys,values)
                 pythonD = Dictionary.PythonDictionary(d)
                 nodes.append((i, pythonD))
@@ -6776,7 +6799,7 @@ class Graph:
             for adjVertex in adjVertices:
                 adjIndex = Vertex.Index(vertex=adjVertex, vertices=vertices, strict=True, tolerance=tolerance)
                 if not adjIndex == None:
-                    nxGraph.add_edge(i,adjIndex, length=(Vertex.Distance(v, adjVertex)))
+                    nxGraph.add_edge(i,adjIndex, length=(Vertex.Distance(v, adjVertex, mantissa=mantissa)))
 
         pos=nx.spring_layout(nxGraph, k=0.2)
         nx.set_node_attributes(nxGraph, pos, "pos")

topologicpy/Grid.py

@@ -18,7 +18,7 @@ import topologic_core as topologic
 
 class Grid():
     @staticmethod
-    def EdgesByDistances(face=None, uOrigin=None, vOrigin=None, uRange=[-0.5,-0.25,0, 0.25,0.5], vRange=[-0.5,-0.25,0, 0.25,0.5], clip=False, tolerance=0.0001):
+    def EdgesByDistances(face=None, uOrigin=None, vOrigin=None, uRange=[-0.5,-0.25,0, 0.25,0.5], vRange=[-0.5,-0.25,0, 0.25,0.5], clip=False, mantissa: int = 6, tolerance=0.0001):
         """
         Creates a grid (cluster of edges).
 
@@ -36,6 +36,8 @@ class Grid():
             A list of distances for the *v* grid lines from the vOrigin. The default is [-0.5,-0.25,0, 0.25,0.5].
         clip : bool , optional
             If True the grid will be clipped by the shape of the input face. The default is False.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -52,6 +54,7 @@ class Grid():
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Vector import Vector
+
         if len(uRange) < 1 or len(vRange) < 1:
             return None
         if not uOrigin:
@@ -76,16 +79,16 @@ class Grid():
             v3 = Vertex.ByCoordinates(0, 0, 0)
             v4 = Vertex.ByCoordinates(0,max(vRange),0)
 
-        uVector = [v2.X()-v1.X(), v2.Y()-v1.Y(),v2.Z()-v1.Z()]
-        vVector = [v4.X()-v3.X(), v4.Y()-v3.Y(),v4.Z()-v3.Z()]
+        uVector = [Vertex.X(v2, mantissa=mantissa)-Vertex.X(v1, mantissa=mantissa), Vertex.Y(v2, mantissa=mantissa)-Vertex.Y(v1, mantissa=mantissa),Vertex.Z(v2, mantissa=mantissa)-Vertex.Z(v1, mantissa=mantissa)]
+        vVector = [Vertex.X(v4, mantissa=mantissa)-Vertex.X(v3, mantissa=mantissa), Vertex.Y(v4, mantissa=mantissa)-Vertex.Y(v3, mantissa=mantissa),Vertex.Z(v4, mantissa=mantissa)-Vertex.Z(v3, mantissa=mantissa)]
         gridEdges = []
         if len(uRange) > 0:
             uRange.sort()
             uuVector = Vector.Normalize(uVector)
             for u in uRange:
                 tempVec = Vector.Multiply(uuVector, u, tolerance)
-                v1 = Vertex.ByCoordinates(uOrigin.X()+tempVec[0], uOrigin.Y()+tempVec[1], uOrigin.Z()+tempVec[2])
-                v2 = Vertex.ByCoordinates(v1.X()+vVector[0], v1.Y()+vVector[1], v1.Z()+vVector[2])
+                v1 = Vertex.ByCoordinates(Vertex.X(uOrigin, mantissa=mantissa)+tempVec[0], Vertex.Y(uOrigin, mantissa=mantissa)+tempVec[1], Vertex.Z(uOrigin, mantissa=mantissa)+tempVec[2])
+                v2 = Vertex.ByCoordinates(Vertex.X(v1, mantissa=mantissa)+vVector[0], Vertex.Y(v1, mantissa=mantissa)+vVector[1], Vertex.Z(v1, mantissa=mantissa)+vVector[2])
                 e = Edge.ByVertices([v1, v2], tolerance=tolerance)
                 if clip and Topology.IsInstance(face, "Face"):
                     e = e.Intersect(face, False)
@@ -105,8 +108,8 @@ class Grid():
             uvVector = Vector.Normalize(vVector)
             for v in vRange:
                 tempVec = Vector.Multiply(uvVector, v, tolerance)
-                v1 = Vertex.ByCoordinates(vOrigin.X()+tempVec[0], vOrigin.Y()+tempVec[1], vOrigin.Z()+tempVec[2])
-                v2 = Vertex.ByCoordinates(v1.X()+uVector[0], v1.Y()+uVector[1], v1.Z()+uVector[2])
+                v1 = Vertex.ByCoordinates(Vertex.X(vOrigin, mantissa=mantissa)+tempVec[0], Vertex.Y(vOrigin, mantissa=mantissa)+tempVec[1], Vertex.Z(vOrigin, mantissa=mantissa)+tempVec[2])
+                v2 = Vertex.ByCoordinates(Vertex.X(v1, mantissa=mantissa)+uVector[0], Vertex.Y(v1, mantissa=mantissa)+uVector[1], Vertex.Z(v1, mantissa=mantissa)+uVector[2])
                 e = Edge.ByVertices([v1, v2], tolerance=tolerance)
                 if clip and Topology.IsInstance(face, "Face"):
                     e = e.Intersect(face, False)

topologicpy/Honeybee.py

@@ -195,17 +195,18 @@ class Honeybee:
     @staticmethod
     def ModelByTopology(tpBuilding,
                 tpShadingFacesCluster = None,
-                buildingName = "Generic_Building",
-                defaultProgramIdentifier = "Generic Office Program",
-                defaultConstructionSetIdentifier = "Default Generic Construction Set",
-                coolingSetpoint = 25.0,
-                heatingSetpoint = 20.0,
-                humidifyingSetpoint = 30.0,
-                dehumidifyingSetpoint = 55.0,
-                roomNameKey = "TOPOLOGIC_name",
-                roomTypeKey = "TOPOLOGIC_type",
-                apertureTypeKey = "TOPOLOGIC_type",
-                addSensorGrid = False):
+                buildingName: str = "Generic_Building",
+                defaultProgramIdentifier: str = "Generic Office Program",
+                defaultConstructionSetIdentifier: str = "Default Generic Construction Set",
+                coolingSetpoint: float = 25.0,
+                heatingSetpoint: float = 20.0,
+                humidifyingSetpoint: float = 30.0,
+                dehumidifyingSetpoint: float = 55.0,
+                roomNameKey: str = "TOPOLOGIC_name",
+                roomTypeKey: str = "TOPOLOGIC_type",
+                apertureTypeKey: str = "TOPOLOGIC_type",
+                addSensorGrid: bool = False,
+                mantissa: int = 6):
         """
         Creates an HB Model from the input Topology.
 
@@ -330,11 +331,11 @@ class Honeybee:
             if tpCellFaces:
                 hbRoomFaces = []
                 for tpFaceNumber, tpCellFace in enumerate(tpCellFaces):
-                    tpCellFaceNormal = Face.NormalAtParameters(tpCellFace, 0.5, 0.5)
+                    tpCellFaceNormal = Face.Normal(tpCellFace, mantissa=mantissa)
                     hbRoomFacePoints = []
                     tpFaceVertices = Wire.Vertices(Face.ExternalBoundary(tpCellFace))
                     for tpVertex in tpFaceVertices:
-                        hbRoomFacePoints.append(Point3D(tpVertex.X(), tpVertex.Y(), tpVertex.Z()))
+                        hbRoomFacePoints.append(Point3D(Vertex.X(tpVertex, mantissa=mantissa), Vertex.Y(tpVertex, mantissa=mantissa), Vertex.Z(tpVertex, mantissa=mantissa)))
                     hbRoomFace = HBFace(tpCellName+'_Face_'+str(tpFaceNumber+1), Face3D(hbRoomFacePoints))
                     tpFaceApertures = []
                     _ = tpCellFace.Apertures(tpFaceApertures)
@@ -349,7 +350,7 @@ class Honeybee:
                             tpFaceApertureVertices = []
                             tpFaceApertureVertices = Wire.Vertices(Face.ExternalBoundary(apertureTopology))
                             for tpFaceApertureVertex in tpFaceApertureVertices:
-                                hbFaceAperturePoints.append(Point3D(tpFaceApertureVertex.X(), tpFaceApertureVertex.Y(), tpFaceApertureVertex.Z()))
+                                hbFaceAperturePoints.append(Point3D(Vertex.X(tpFaceApertureVertex, mantissa=mantissa), Vertex.Y(tpFaceApertureVertex, mantissa=mantissa), Vertex.Z(tpFaceApertureVertex, mantissa=mantissa)))
                             if(tpFaceApertureType):
                                 if ("door" in tpFaceApertureType.lower()):
                                     hbFaceAperture = HBDoor(tpCellName+'_Face_'+str(tpFaceNumber+1)+'_Door_'+str(tpFaceApertureNumber), Face3D(hbFaceAperturePoints))
@@ -398,7 +399,7 @@ class Honeybee:
                 faceVertices = Wire.Vertices(Face.ExternalBoundary(tpShadingFace))
                 facePoints = []
                 for aVertex in faceVertices:
-                    facePoints.append(Point3D(aVertex.X(), aVertex.Y(), aVertex.Z()))
+                    facePoints.append(Point3D(Vertex.X(aVertex, mantissa=mantissa), Vertex.Y(aVertex, mantissa=mantissa), Vertex.Z(aVertex, mantissa=mantissa)))
                 hbShadingFace = Face3D(facePoints, None, [])
                 hbShade = HBShade("SHADINGSURFACE_" + str(faceIndex+1), hbShadingFace)
                 hbShades.append(hbShade)

topologicpy/Neo4j.py

@@ -276,7 +276,7 @@ class Neo4j:
         return Graph.ByVerticesEdges(vertices,edges)
     
     @staticmethod
-    def AddGraph(neo4jGraph, graph, labelKey=None, relationshipKey=None, bidirectional=True, deleteAll=True, tolerance=0.0001):
+    def AddGraph(neo4jGraph, graph, labelKey=None, relationshipKey=None, bidirectional=True, deleteAll=True, mantissa: int = 6, tolerance: float = 0.0001):
         """
         Adds the input topologic graph to the input neo4j graph
 
@@ -288,6 +288,8 @@ class Neo4j:
             The input topologic graph.
         categoryKey : str
             The category key in the dictionary under which to look for the category value.
+        mantissa : int, optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -301,6 +303,7 @@ class Neo4j:
         from topologicpy.Topology import Topology
         from topologicpy.Graph import Graph
         from topologicpy.Dictionary import Dictionary
+
         gmt = time.gmtime()
         timestamp =  str(gmt.tm_zone)+"_"+str(gmt.tm_year)+"_"+str(gmt.tm_mon)+"_"+str(gmt.tm_wday)+"_"+str(gmt.tm_hour)+"_"+str(gmt.tm_min)+"_"+str(gmt.tm_sec)
         vertices = Graph.Vertices(graph)
@@ -316,11 +319,11 @@ class Neo4j:
             keys.append("z")
             keys.append("timestamp")
             keys.append("location")
-            values.append(vertices[i].X())
-            values.append(vertices[i].Y())
-            values.append(vertices[i].Z())
+            values.append(Vertex.X(vertices[i], mantissa=mantissa))
+            values.append(Vertex.Y(vertices[i], mantissa=mantissa))
+            values.append(Vertex.Z(vertices[i], mantissa=mantissa))
             values.append(timestamp)
-            values.append(sp.CartesianPoint([vertices[i].X(),vertices[i].Y(),vertices[i].Z()]))
+            values.append(sp.CartesianPoint([Vertex.X(vertices[i], mantissa=mantissa), Vertex.Y(vertices[i], mantissa=mantissa), Vertex.Z(vertices[i], mantissa=mantissa)]))
             zip_iterator = zip(keys, values)
             pydict = dict(zip_iterator)
             if labelKey == 'None':
@@ -427,7 +430,14 @@ class Neo4j:
         return list(neo4jGraph.schema.relationship_types)
     
     @staticmethod
-    def SetGraph(neo4jGraph, graph, labelKey=None, relationshipKey=None, bidirectional=True, deleteAll=True, tolerance=0.0001):
+    def SetGraph(neo4jGraph,
+                 graph,
+                 labelKey: str = None,
+                 relationshipKey: str = None,
+                 bidirectional: bool = True,
+                 deleteAll: bool = True,
+                 mantissa: int = 6,
+                 tolerance: float = 0.0001):
         """
         Sets the input topologic graph to the input neo4jGraph.
 
@@ -445,6 +455,8 @@ class Neo4j:
             If set to True, the edges in the neo4j graph are set to be bi-drectional.
         deleteAll : bool , optional
             If set to True, all previous entities are deleted before adding the new entities.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -484,11 +496,11 @@ class Neo4j:
             keys.append("z")
             keys.append("timestamp")
             keys.append("location")
-            values.append(vertices[i].X())
-            values.append(vertices[i].Y())
-            values.append(vertices[i].Z())
+            values.append(Vertex.X(vertices[i], mantissa=mantissa))
+            values.append(Vertex.Y(vertices[i], mantissa=mantissa))
+            values.append(Vertex.Z(vertices[i], mantissa=mantissa))
             values.append(timestamp)
-            values.append(sp.CartesianPoint([vertices[i].X(),vertices[i].Y(),vertices[i].Z()]))
+            values.append(sp.CartesianPoint([Vertex.X(vertices[i], mantissa=mantissa), Vertex.Y(vertices[i], mantissa=mantissa), Vertex.Z(vertices[i], mantissa=mantissa)]))
             zip_iterator = zip(keys, values)
             pydict = dict(zip_iterator)
             if (labelKey == 'None') or (not (labelKey)):