topologicpy 0.7.43__py3-none-any.whl → 0.7.45__py3-none-any.whl

topologicpy/Cell.py

@@ -1519,6 +1519,7 @@ class Cell():
         
         from topologicpy.Vertex import Vertex
         from topologicpy.Face import Face
+        from topologicpy.Shell import Shell
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(origin, "Vertex"):
@@ -1552,6 +1553,132 @@ class Cell():
         octahedron = Topology.Place(octahedron, originA=Vertex.Origin(), originB=origin)
         return octahedron
     
+    @staticmethod
+    def Paraboloid(origin= None, focalLength=0.125, width: float = 1, length: float = 1, height: float = 0, uSides: int = 16, vSides: int = 16,
+                        direction: list = [0, 0, 1], placement: str ="center", mantissa: int = 6, tolerance: float = 0.0001, silent=False):
+        """
+        Creates a paraboloid cell. See https://en.wikipedia.org/wiki/Paraboloid
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The origin location of the parabolic surface. The default is None which results in the parabolic surface being placed at (0, 0, 0).
+        focalLength : float , optional
+            The focal length of the parabola. The default is 0.125.
+        width : float , optional
+            The width of the parabolic surface. The default is 1.
+        length : float , optional
+            The length of the parabolic surface. The default is 1.
+        height : float , optional
+            The additional height of the parabolic surface. Please note this is not the height from the spring point to the apex. It is in addition to that to form a base. The default is 0.
+        uSides : int , optional
+            The number of sides along the width. The default is 16.
+        vSides : int , optional
+            The number of sides along the length. The default is 16.
+        direction : list , optional
+            The vector representing the up direction of the parabolic surface. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the parabolic surface. 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.
+        silent : bool , optional
+        If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        topologic_core.Shell
+            The created paraboloid.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+        from topologicpy.Face import Face
+        from topologicpy.Wire import Wire
+        from topologicpy.Shell import Shell
+
+        if origin == None:
+            origin = Vertex.Origin()
+        
+        if not Topology.IsInstance(origin, "Vertex"):
+            if not silent:
+                print("Cell.Paraboloid - Error: The origin input parameter is not a valid vertex. Returning None.")
+            return None
+        if width <= 0:
+            if not silent:
+                print("Cell.Paraboloid - Error: The width input parameter cannot be less than or equal to zero. Returning None.")
+            return None
+        if length <= 0:
+            if not silent:
+                print("Cell.Paraboloid - Error: The length input parameter cannot be less than or equal to zero. Returning None.")
+            return None
+        if height < 0:
+            if not silent:
+                print("Cell.Paraboloid - Error: The height input parameter cannot be negative. Returning None.")
+            return None
+        
+        para = Shell.Paraboloid(focalLength=focalLength, width=width, length=length, uSides=uSides, vSides=vSides,
+                        direction=[0,0,1], placement="center", mantissa=mantissa, tolerance=tolerance)
+        if not Topology.IsInstance(para, "Shell"):
+            if not silent:
+                print("Cell.Paraboloid - Error: Could not create paraboloid. Returning None.")
+            return None
+        eb = Shell.ExternalBoundary(para)
+        vertices = Topology.Vertices(eb)
+        z_list = [Vertex.Z(v) for v in vertices]
+        if focalLength > 0:
+            z = max(z_list) + height
+        else:
+            z = min(z_list) - height
+        f = Face.Rectangle(origin=Vertex.ByCoordinates(0,0,z), width=width*1.1, length=length*1.1)
+        proj_vertices = []
+        for v in vertices:
+            proj_vertices.append(Vertex.Project(v, f))
+        w = Wire.ByVertices(proj_vertices, close=True)
+        sleeve = Shell.ByWires([eb, w], triangulate=False, silent=True)
+        if sleeve == None:
+            if not silent:
+                print("Cell.Paraboloid - Error: Could not create paraboloid. Returning None.")
+            return None
+        f = Face.ByWire(w, tolerance=tolerance)
+        faces = Topology.Faces(sleeve) + [f] + Topology.Faces(para)
+        cell = Cell.ByFaces(faces, tolerance=tolerance)
+        if cell == None:
+            if not silent:
+                print("Cell.Paraboloid - Error: Could not create paraboloid. Returning None.")
+            return None
+        vertices = Topology.Vertices(cell)
+        x_list = [Vertex.X(v, mantissa=mantissa) for v in vertices]
+        y_list = [Vertex.Y(v, mantissa=mantissa) for v in vertices]
+        z_list = [Vertex.Z(v, mantissa=mantissa) for v in vertices]
+        min_x = min(x_list)
+        max_x = max(x_list)
+        mid_x = min_x + (max_x - min_x)/2
+        min_y = min(y_list)
+        max_y = max(y_list)
+        mid_y = min_y + (max_y - min_y)/2
+        min_z = min(z_list)
+        max_z = max(z_list)
+        mid_z = min_z + (max_z - min_z)/2
+        if placement.lower() == "center":
+            x_tran = -mid_x
+            y_tran = -mid_y
+            z_tran = -mid_z
+        elif placement.lower() == "bottom":
+            x_tran = -mid_x
+            y_tran = -mid_y
+            z_tran = -min_z
+        elif placement.lower() == "lowerleft":
+            x_tran = -min_x
+            y_tran = -min_y
+            z_tran = -min_z
+        cell = Topology.Translate(cell, x_tran, y_tran, z_tran)
+        cell = Topology.Place(cell, originA=Vertex.Origin(), originB=origin)
+        if not direction == [0,0,1]:
+            cell = Topology.Orient(cell, origin=origin, dirA=[0,0,1], dirB=direction)
+        return cell
+
     @staticmethod
     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:
         """

topologicpy/EnergyModel.py

@@ -20,7 +20,7 @@ import math
 from collections import OrderedDict
 import os
 from os.path import exists
-from datetime import datetime
+from datetime import datetime, timezone
 import warnings
 
 try:
@@ -249,18 +249,24 @@ class EnergyModel:
             weatherFilePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "GBR_London.Gatwick.037760_IWEC.epw")
             designDayFilePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "GBR_London.Gatwick.037760_IWEC.ddy")
         translator = openstudio.osversion.VersionTranslator()
-        osmFile = openstudio.openstudioutilitiescore.toPath(osModelPath)
-        osModel = translator.loadModel(osmFile)
+        # DEBUGGING
+        #osmFile = openstudio.openstudioutilitiescore.toPath(osModelPath)
+        #osModel = translator.loadModel(osmFile)
+        osModel = translator.loadModel(osModelPath)
         if osModel.isNull():
             print("EnergyModel.ByTopology - Error: The openstudio model is null. Returning None.")
             return None
         else:
             osModel = osModel.get()
-        osEPWFile = openstudio.openstudioutilitiesfiletypes.EpwFile.load(openstudio.toPath(weatherFilePath))
+        # DEBUGGING
+        #osEPWFile = openstudio.openstudioutilitiesfiletypes.EpwFile.load(openstudio.toPath(weatherFilePath))
+        osEPWFile = openstudio.openstudioutilitiesfiletypes.EpwFile.load(weatherFilePath)
         if osEPWFile.is_initialized():
             osEPWFile = osEPWFile.get()
             openstudio.model.WeatherFile.setWeatherFile(osModel, osEPWFile)
-        ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(openstudio.toPath(designDayFilePath))
+        # DEBUGGING
+        #ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(openstudio.toPath(designDayFilePath))
+        ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(designDayFilePath)
         if ddyModel.is_initialized():
             ddyModel = ddyModel.get()
             for ddy in ddyModel.getObjectsByType(openstudio.IddObjectType("OS:SizingPeriod:DesignDay")):
@@ -578,8 +584,9 @@ class EnergyModel:
         if not overwrite and exists(path):
             print("EnergyModel.ExportToGBXML - Error: a file already exists at the specified path and overwrite is set to False. Returning None.")
             return None
-
-        return openstudio.gbxml.GbXMLForwardTranslator().modelToGbXML(model, openstudio.openstudioutilitiescore.toPath(path))
+        # DEBUGGING
+        #return openstudio.gbxml.GbXMLForwardTranslator().modelToGbXML(model, openstudio.openstudioutilitiescore.toPath(path))
+        return openstudio.gbxml.GbXMLForwardTranslator().modelToGbXML(model, path)
 
     
     @staticmethod
@@ -629,8 +636,10 @@ class EnergyModel:
             print("EnergyModel.ExportToOSM - Error: a file already exists at the specified path and overwrite is set to False. Returning None.")
             return None
         osCondition = False
-        osPath = openstudio.openstudioutilitiescore.toPath(path)
-        osCondition = model.save(osPath, overwrite)
+        # DEBUGGING
+        #osPath = openstudio.openstudioutilitiescore.toPath(path)
+        #osCondition = model.save(osPath, overwrite)
+        osCondition = model.save(path, overwrite)
         return osCondition
     
     @staticmethod
@@ -821,7 +830,7 @@ class EnergyModel:
         if removeFiles:
             deleteOldFiles(outputFolder)
         pbar = tqdm(desc='Running Simulation', total=100, leave=False)
-        utcnow = datetime.utcnow()
+        utcnow = datetime.now(timezone.utc)
         timestamp = utcnow.strftime("UTC-%Y-%m-%d-%H-%M-%S")
         if not outputFolder:
             home = os.path.expanduser('~')
@@ -831,28 +840,32 @@ class EnergyModel:
         os.mkdir(outputFolder)
         pbar.update(10)
         osmPath = os.path.join(outputFolder, model.getBuilding().name().get() + ".osm")
-        model.save(openstudio.openstudioutilitiescore.toPath(osmPath), True)
+        # DEBUGGING
+        #model.save(openstudio.openstudioutilitiescore.toPath(osmPath), True)
+        model.save(osmPath, True)
         oswPath = os.path.join(outputFolder, model.getBuilding().name().get() + ".osw")
         pbar.update(20)
-        #print("oswPath = "+oswPath)
         workflow = model.workflowJSON()
-        workflow.setSeedFile(openstudio.openstudioutilitiescore.toPath(osmPath))
+        # DEBUGGING
+        #workflow.setSeedFile(openstudio.openstudioutilitiescore.toPath(osmPath))
+        workflow.setSeedFile(osmPath)
         pbar.update(30)
-        #print("Seed File Set")
-        workflow.setWeatherFile(openstudio.openstudioutilitiescore.toPath(weatherFilePath))
+        # DEBUGGING
+        #workflow.setWeatherFile(openstudio.openstudioutilitiescore.toPath(weatherFilePath))
+        workflow.setWeatherFile(weatherFilePath)
         pbar.update(40)
-        #print("Weather File Set")
-        workflow.saveAs(openstudio.openstudioutilitiescore.toPath(oswPath))
+        # DEBUGGING
+        #workflow.saveAs(openstudio.openstudioutilitiescore.toPath(oswPath))
+        workflow.saveAs(oswPath)
         pbar.update(50)
-        #print("OSW File Saved")
         cmd = osBinaryPath+" run -w " + "\"" + oswPath + "\""
         pbar.update(60)
         os.system(cmd)
-        #print("Simulation DONE")
         sqlPath = os.path.join(os.path.join(outputFolder,"run"), "eplusout.sql")
         pbar.update(100)
-        #print("sqlPath = "+sqlPath)
-        osSqlFile = openstudio.SqlFile(openstudio.openstudioutilitiescore.toPath(sqlPath))
+        # DEBUGGING
+        #osSqlFile = openstudio.SqlFile(openstudio.openstudioutilitiescore.toPath(sqlPath))
+        osSqlFile = openstudio.SqlFile(sqlPath)
         model.setSqlFile(osSqlFile)
         pbar.close()
         return model

topologicpy/Face.py

@@ -451,7 +451,7 @@ class Face():
         planar_shell = Shell.Planarize(shell)
         normal = Face.Normal(Topology.Faces(planar_shell)[0])
         planar_shell = Topology.Flatten(planar_shell, origin=origin, direction=normal)
-        vertices = Shell.Vertices(planar_shell)
+        vertices = Topology.Vertices(planar_shell)
         new_vertices = []
         for v in vertices:
             x, y, z = Vertex.Coordinates(v)

topologicpy/Graph.py

@@ -712,7 +712,7 @@ class Graph:
         return paths
 
     @staticmethod
-    def AverageClusteringCoefficient(graph, mantissa=6):
+    def AverageClusteringCoefficient(graph, mantissa: int = 6):
         """
         Returns the average clustering coefficient of the input graph. See https://en.wikipedia.org/wiki/Clustering_coefficient.
 
@@ -1199,7 +1199,7 @@ class Graph:
         return bot_graph.serialize(format=format)
 
     @staticmethod
-    def BetweenessCentrality(graph, vertices=None, sources=None, destinations=None, tolerance=0.001):
+    def BetweenessCentrality(graph, vertices=None, sources=None, destinations=None, key: str = "betweeness_centrality", mantissa: int = 6, tolerance: float = 0.001):
         """
             Returns the betweeness centrality measure of the input list of vertices within the input graph. The order of the returned list is the same as the order of the input list of vertices. If no vertices are specified, the betweeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Betweenness_centrality.
 
@@ -1213,6 +1213,10 @@ class Graph:
             The input list of source vertices. The default is None which means all vertices in the input graph are considered.
         destinations : list , optional
             The input list of destination vertices. The default is None which means all vertices in the input graph are considered.
+        key : str , optional
+            The dictionary key under which to save the betweeness centrality score. The default is "betweneess_centrality".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -1224,6 +1228,7 @@ class Graph:
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
 
         def betweeness(vertices, topologies, tolerance=0.001):
             returnList = [0] * len(vertices)
@@ -1281,12 +1286,16 @@ class Graph:
                         if path:
                             paths.append(path)
 
-        values = betweeness(vertices, paths, tolerance=tolerance)
-        minValue = min(values)
-        maxValue = max(values)
+        scores = betweeness(vertices, paths, tolerance=tolerance)
+        minValue = min(scores)
+        maxValue = max(scores)
         size = maxValue - minValue
-        values = [(v-minValue)/size for v in values]
-        return values
+        scores = [round((v-minValue)/size, mantissa) for v in scores]
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            d = Dictionary.SetValueAtKey(d, key, scores[i])
+            v = Topology.SetDictionary(v, d)
+        return scores
     
     @staticmethod
     def ByAdjacencyMatrixCSVPath(path: str, dictionaries: list = None, silent: bool = False):
@@ -4064,7 +4073,7 @@ class Graph:
         return chromatic_number(adj_matrix)
 
     @staticmethod
-    def Color(graph, oldKey: str = "color", newKey: str = "color", maxColors: int = None, tolerance: float = 0.0001):
+    def Color(graph, oldKey: str = "color", key: str = "color", maxColors: int = None, tolerance: float = 0.0001):
         """
         Colors the input vertices within the input graph. The saved value is an integer rather than an actual color. See Color.ByValueInRange to convert to an actual color.
         Any vertices that have been pre-colored will not be affected. See https://en.wikipedia.org/wiki/Graph_coloring.
@@ -4075,7 +4084,7 @@ class Graph:
             The input graph.
         oldKey : str , optional
             The existing dictionary key to use to read any pre-existing color information. The default is "color".
-        newKey : str , optional
+        key : str , optional
             The new dictionary key to use to write out new color information. The default is "color".
         maxColors : int , optional
             The desired maximum number of colors to use. If set to None, the chromatic number of the graph is used. The default is None.
@@ -4152,7 +4161,7 @@ class Graph:
         colors = graph_coloring(adj_mat, maxColors, colors)
         for i, v in enumerate(vertices):
                 d = Topology.Dictionary(v)
-                d = Dictionary.SetValueAtKey(d, newKey, colors[i])
+                d = Dictionary.SetValueAtKey(d, key, colors[i])
                 v = Topology.SetDictionary(v, d)
         return graph
     
@@ -4259,7 +4268,7 @@ class Graph:
         return graph
     
     @staticmethod
-    def ClosenessCentrality(graph, vertices=None, tolerance = 0.0001):
+    def ClosenessCentrality(graph, vertices=None, key: str = "closeness_centrality", mantissa: int = 6, tolerance = 0.0001):
         """
         Return the closeness centrality measure of the input list of vertices within the input graph. The order of the returned list is the same as the order of the input list of vertices. If no vertices are specified, the closeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Closeness_centrality.
 
@@ -4269,6 +4278,10 @@ class Graph:
             The input graph.
         vertices : list , optional
             The input list of vertices. The default is None.
+        key : str , optional
+            The dictionary key under which to save the closeness centrality score. The default is "closeness_centrality".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -4279,6 +4292,7 @@ class Graph:
 
         """
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
 
         if not Topology.IsInstance(graph, "Graph"):
             print("Graph.ClosenessCentrality - Error: The input graph is not a valid graph. Returning None.")
@@ -4293,7 +4307,7 @@ class Graph:
             return None
         n = len(graphVertices)
 
-        returnList = []
+        scores = []
         try:
             for va in tqdm(vertices, desc="Computing Closeness Centrality", leave=False):
                 top_dist = 0
@@ -4304,9 +4318,9 @@ class Graph:
                         d = Graph.TopologicalDistance(graph, va, vb, tolerance)
                     top_dist += d
                 if top_dist == 0:
-                    returnList.append(0)
+                    scores.append(0)
                 else:
-                    returnList.append((n-1)/top_dist)
+                    scores.append(round((n-1)/top_dist, mantissa))
         except:
             print("Graph.ClosenessCentrality - Warning: Could not use tqdm.")
             for va in vertices:
@@ -4318,10 +4332,14 @@ class Graph:
                         d = Graph.TopologicalDistance(graph, va, vb, tolerance)
                     top_dist += d
                 if top_dist == 0:
-                    returnList.append(0)
+                    scores.append(0)
                 else:
-                    returnList.append((n-1)/top_dist)
-        return returnList
+                    scores.append(round((n-1)/top_dist, mantissa))
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            d = Dictionary.SetValueAtKey(d, key, scores[i])
+            v = Topology.SetDictionary(v, d)
+        return scores
 
     @staticmethod
     def Connect(graph, verticesA, verticesB, tolerance=0.0001):
@@ -4430,6 +4448,61 @@ class Graph:
             return None
         return graph.ContainsVertex(vertex, tolerance)
 
+
+    @staticmethod
+    def Degree(graph, vertices=None, key: str = "degree", edgeKey: str = None, mantissa: int = 6, tolerance = 0.0001):
+        """
+        Return the degree measure of the input list of vertices within the input graph. The order of the returned list is the same as the order of the input list of vertices. If no vertices are specified, the closeness centrality of all the vertices in the input graph is computed. See https://en.wikipedia.org/wiki/Degree_(graph_theory).
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertices : list , optional
+            The input list of vertices. The default is None.
+        key : str , optional
+            The dictionary key under which to save the closeness centrality score. The default is "degree".
+        edgeKey : str , optional
+            If specified, the value in the connected edges' dictionary specified by the edgeKey string will be aggregated to calculate
+            the vertex degree. If a numeric value cannot be retrieved from an edge, a value of 1 is used instead. This is used in weighted graphs.
+        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
+        -------
+        list
+            The degree of the input list of vertices within the input graph.
+
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        if not Topology.IsInstance(graph, "Graph"):
+            print("Graph.ClosenessCentrality - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        graphVertices = Graph.Vertices(graph)
+        if not isinstance(vertices, list):
+            vertices = graphVertices
+        else:
+            vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
+        if len(vertices) < 1:
+            print("Graph.Degree - Error: The input list of vertices does not contain any valid vertices. Returning None.")
+            return None
+        n = len(graphVertices)
+
+        scores = []
+        for i, v in enumerate(vertices):
+            degree = Graph.VertexDegree(graph, v, edgeKey= edgeKey, tolerance = tolerance)
+            if isinstance(degree, float):
+                degree = round(degree, mantissa)
+            d = Topology.Dictionary(v)
+            d = Dictionary.SetValueAtKey(d, key, degree)
+            v = Topology.SetDictionary(v, d)
+            scores.append(degree)
+        return scores
+    
     @staticmethod
     def DegreeSequence(graph):
         """
@@ -4479,7 +4552,7 @@ class Graph:
         return graph.Density()
     
     @staticmethod
-    def DepthMap(graph, vertices=None, tolerance=0.0001):
+    def DepthMap(graph, vertices=None, key: str = "depth", type: str = "topological", mantissa: int = 6, tolerance: float = 0.0001):
         """
         Return the depth map of the input list of vertices within the input graph. The returned list contains the total of the topological distances of each vertex to every other vertex in the input graph. The order of the depth map list is the same as the order of the input list of vertices. If no vertices are specified, the depth map of all the vertices in the input graph is computed.
 
@@ -4489,6 +4562,12 @@ class Graph:
             The input graph.
         vertices : list , optional
             The input list of vertices. The default is None.
+        key : str , optional
+            The dictionary key under which to save the depth score. The default is "depth".
+        type : str , optional
+            The type of depth distance to calculate. The options are "topological" or "metric". The default is "topological". See https://www.spacesyntax.online/overview-2/analysis-of-spatial-relations/.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -4499,6 +4578,7 @@ class Graph:
 
         """
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
 
         if not Topology.IsInstance(graph, "Graph"):
             print("Graph.DepthMap - Error: The input graph is not a valid graph. Returning None.")
@@ -4511,17 +4591,21 @@ class Graph:
         if len(vertices) < 1:
             print("Graph.DepthMap - Error: The input list of vertices does not contain any valid vertices. Returning None.")
             return None
-        depthMap = []
+        scores = []
         for va in vertices:
             depth = 0
             for vb in graphVertices:
                 if Topology.IsSame(va, vb):
                     dist = 0
                 else:
-                    dist = Graph.TopologicalDistance(graph, va, vb, tolerance)
+                    dist = Graph.Distance(graph, va, vb, type=type, mantissa=mantissa, tolerance=tolerance)
                 depth = depth + dist
-            depthMap.append(depth)
-        return depthMap
+            depth = round(depth, mantissa)
+            d = Topology.Dictionary(va)
+            d = Dictionary.SetValueAtKey(d, key, depth)
+            va = Topology.SetDictionary(va, d)
+            scores.append(depth)
+        return scores
     
     @staticmethod
     def Diameter(graph):
@@ -4570,7 +4654,7 @@ class Graph:
         return graph.GetDictionary()
     
     @staticmethod
-    def Distance(graph, vertexA, vertexB, tolerance=0.0001):
+    def Distance(graph, vertexA, vertexB, type: str = "topological", mantissa: int = 6, tolerance: float = 0.0001):
         """
         Returns the shortest-path distance between the input vertices. See https://en.wikipedia.org/wiki/Distance_(graph_theory).
 
@@ -4582,16 +4666,22 @@ class Graph:
             The first input vertex.
         vertexB : topologic_core.Vertex
             The second input vertex.
+        type : str , optional
+            The type of depth distance to calculate. The options are "topological" or "metric". The default is "topological". See https://www.spacesyntax.online/overview-2/analysis-of-spatial-relations/.
+        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
         -------
-        int
-            The shortest-path distance between the input vertices.
+        float
+            The shortest-path metric distance between the input vertices.
 
         """
         from topologicpy.Topology import Topology
+        from topologicpy.Wire import Wire
+        from topologicpy.Edge import Edge
 
         if not Topology.IsInstance(graph, "Graph"):
             print("Graph.Distance - Error: The input graph is not a valid graph. Returning None.")
@@ -4602,8 +4692,11 @@ class Graph:
         if not Topology.IsInstance(vertexB, "Vertex"):
             print("Graph.Distance - Error: The input vertexB is not a valid vertex. Returning None.")
             return None
-        return graph.TopologicalDistance(vertexA, vertexB, tolerance)
-
+        
+        if "topo" in type.lower():
+            return Graph.TopologicalDistance(graph, vertexA, vertexB, tolerance=tolerance)
+        return Graph.MetricDistance(graph, vertexA, vertexB, mantissa=mantissa, tolerance=tolerance)
+    
     @staticmethod
     def Edge(graph, vertexA, vertexB, tolerance=0.0001):
         """
@@ -6520,7 +6613,7 @@ class Graph:
         return json_string
     
     @staticmethod
-    def LocalClusteringCoefficient(graph, vertices: list = None, mantissa: int = 6, tolerance: float = 0.0001):
+    def LocalClusteringCoefficient(graph, vertices: list = None, key: str = "lcc", mantissa: int = 6, tolerance: float = 0.0001):
         """
         Returns the local clustering coefficient of the input list of vertices within the input graph. See https://en.wikipedia.org/wiki/Clustering_coefficient.
 
@@ -6530,6 +6623,8 @@ class Graph:
             The input graph.
         vertices : list , optional
             The input list of vertices. If set to None, the local clustering coefficient of all vertices will be computed. The default is None.
+        key : str , optional
+            The dictionary key under which to save the local clustering coefficient score. The default is "lcc".
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional
@@ -6543,6 +6638,7 @@ class Graph:
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
 
         def local_clustering_coefficient(adjacency_matrix, node):
             """
@@ -6585,14 +6681,18 @@ class Graph:
             return None
         g_vertices = Graph.Vertices(graph)
         adjacency_matrix = Graph.AdjacencyMatrix(graph)
-        lcc = []
+        scores = []
         for v in vertices:
             i = Vertex.Index(v, g_vertices, tolerance=tolerance)
             if not i == None:
-                lcc.append(round(local_clustering_coefficient(adjacency_matrix, i), mantissa))
+                lcc_score = round(local_clustering_coefficient(adjacency_matrix, i), mantissa)
+                d = Topology.Dictionary(v)
+                d = Dictionary.SetValueAtKey(d, key, lcc_score)
+                v = Topology.SetDictionary(v, d)
+                scores.append(lcc_score)
             else:
-                lcc.append(None)
-        return lcc
+                scores.append(None)
+        return scores
     
     @staticmethod
     def LongestPath(graph, vertexA, vertexB, vertexKey=None, edgeKey=None, costKey=None, timeLimit=10, tolerance=0.0001):
@@ -6889,6 +6989,52 @@ class Graph:
                 'edgeDictionaries': e_dicts
                 }
     
+    @staticmethod
+    def MetricDistance(graph, vertexA, vertexB, mantissa: int = 6, tolerance: float = 0.0001):
+        """
+        Returns the shortest-path distance between the input vertices. See https://en.wikipedia.org/wiki/Distance_(graph_theory).
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertexA : topologic_core.Vertex
+            The first input vertex.
+        vertexB : topologic_core.Vertex
+            The second input vertex.
+        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
+        -------
+        float
+            The shortest-path metric distance between the input vertices.
+
+        """
+        from topologicpy.Topology import Topology
+        from topologicpy.Wire import Wire
+        from topologicpy.Edge import Edge
+
+        if not Topology.IsInstance(graph, "Graph"):
+            print("Graph.MetricDistance - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        if not Topology.IsInstance(vertexA, "Vertex"):
+            print("Graph.MetricDistance - Error: The input vertexA is not a valid vertex. Returning None.")
+            return None
+        if not Topology.IsInstance(vertexB, "Vertex"):
+            print("Graph.MetricDistance - Error: The input vertexB is not a valid vertex. Returning None.")
+            return None
+        sp = Graph.ShortestPath(graph, vertexA, vertexB, vertexKey="", edgeKey="Length", tolerance=tolerance)
+        if Topology.IsInstance(sp, "Wire"):
+            dist = round(Wire.Length(sp), mantissa)
+        elif Topology.IsInstance(sp, "Edge"):
+            dist = round(Edge.Length(sp), mantissa)
+        else:
+            dist = float('inf')
+        return dist
+    
     @staticmethod
     def MinimumDelta(graph):
         """
@@ -7312,7 +7458,7 @@ class Graph:
         return outgoing_vertices
     
     @staticmethod
-    def PageRank(graph, alpha=0.85, maxIterations=100, normalize=True, directed=False, mantissa=6, tolerance=0.0001):
+    def PageRank(graph, alpha: float = 0.85, maxIterations: int = 100, normalize: bool = True, directed: bool = False, key: str = "page_rank", mantissa: int = 6, tolerance: float = 0.0001):
         """
         Calculates PageRank scores for nodes in a directed graph. see https://en.wikipedia.org/wiki/PageRank.
 
@@ -7328,6 +7474,8 @@ class Graph:
             If set to True, the results will be normalized from 0 to 1. Otherwise, they won't be. The default is True.
         directed : bool , optional
             If set to True, the graph is considered as a directed graph. Otherwise, it will be considered as an undirected graph. The default is False.
+        key : str , optional
+            The dictionary key under which to save the page_rank score. The default is "page_rank"
         mantissa : int , optional
             The desired length of the mantissa.
         tolerance : float , optional
@@ -7340,6 +7488,8 @@ class Graph:
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Helper import Helper
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
 
         vertices = Graph.Vertices(graph)
         num_vertices = len(vertices)
@@ -7368,6 +7518,10 @@ class Graph:
             scores = Helper.Normalize(scores, mantissa=mantissa)
         else:
             scores = [round(x, mantissa) for x in scores]
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            d = Dictionary.SetValueAtKey(d, key, scores[i])
+            v = Topology.SetDictionary(v, d)
         return scores
     
     @staticmethod
@@ -7756,13 +7910,14 @@ class Graph:
             gsv = Graph.NearestVertex(graph, vertexA)
             gev = Graph.NearestVertex(graph, vertexB)
             shortest_path = graph.ShortestPath(gsv, gev, vertexKey, edgeKey)
-            if Topology.IsInstance(shortest_path, "Edge"):
-                    shortest_path = Wire.ByEdges([shortest_path])
-            sv = Topology.Vertices(shortest_path)[0]
-            if Vertex.Distance(sv, gev) < tolerance: # Path is reversed. Correct it.
-                if Topology.IsInstance(shortest_path, "Wire"):
-                    shortest_path = Wire.Reverse(shortest_path)
-            shortest_path = Wire.OrientEdges(shortest_path, Wire.StartVertex(shortest_path), tolerance=tolerance)
+            if not shortest_path == None:
+                if Topology.IsInstance(shortest_path, "Edge"):
+                        shortest_path = Wire.ByEdges([shortest_path])
+                sv = Topology.Vertices(shortest_path)[0]
+                if Vertex.Distance(sv, gev) < tolerance: # Path is reversed. Correct it.
+                    if Topology.IsInstance(shortest_path, "Wire"):
+                        shortest_path = Wire.Reverse(shortest_path)
+                shortest_path = Wire.OrientEdges(shortest_path, Wire.StartVertex(shortest_path), tolerance=tolerance)
             return shortest_path
         except:
             return None

topologicpy/Plotly.py

@@ -366,15 +366,12 @@ class Plotly:
                     v_label = ""
                     v_group = ""
                     d = Topology.Dictionary(v)
+                    v_group = Dictionary.ValueAtKey(d, key=vertexGroupKey)
                     if d:
-                        try:
+                        if vertexLabelKey:
                             v_label = str(Dictionary.ValueAtKey(d, key=vertexLabelKey)) or ""
-                        except:
-                            v_label = ""
-                        try:
-                            v_group = Dictionary.ValueAtKey(d, key=vertexGroupKey)
-                        except:
-                            v_group = None
+                        if vertexGroupKey:
+                            v_group = Dictionary.ValueAtKey(d, key=vertexGroupKey) or None
                     try:
                         v_groupList.append(vertexGroups.index(v_group))
                     except:

topologicpy/PyG.py

@@ -30,11 +30,27 @@ from sklearn.metrics import accuracy_score
 from tqdm.auto import tqdm
 import gc
 
+import torch
+from torch.utils.data import Dataset
+
+import torch
+from torch.utils.data import Dataset
 
 class CustomGraphDataset(Dataset):
-    def __init__(self, root, node_level=False, graph_level=True, node_attr_key='feat', 
-                 edge_attr_key='feat', transform=None, pre_transform=None):
-        super(CustomGraphDataset, self).__init__(root, transform, pre_transform)
+    def __init__(self, root=None, data_list=None, indices=None, node_level=False, graph_level=True, 
+                 node_attr_key='feat', edge_attr_key='feat'):
+        """
+        Initializes the CustomGraphDataset.
+
+        Parameters:
+        - root: Root directory of the dataset (used only if data_list is None)
+        - data_list: List of preprocessed data objects (used if provided)
+        - indices: List of indices to select a subset of the data
+        - node_level: Boolean flag indicating if the dataset is node-level
+        - graph_level: Boolean flag indicating if the dataset is graph-level
+        - node_attr_key: Key for node attributes
+        - edge_attr_key: Key for edge attributes
+        """
         assert not (node_level and graph_level), "Both node_level and graph_level cannot be True at the same time"
         assert node_level or graph_level, "Both node_level and graph_level cannot be False at the same time"
 
@@ -43,15 +59,20 @@ class CustomGraphDataset(Dataset):
         self.node_attr_key = node_attr_key
         self.edge_attr_key = edge_attr_key
 
-        self.graph_df = pd.read_csv(os.path.join(root, 'graphs.csv'))
-        self.nodes_df = pd.read_csv(os.path.join(root, 'nodes.csv'))
-        self.edges_df = pd.read_csv(os.path.join(root, 'edges.csv'))
-
-        self.data_list = self.process_all()
+        if data_list is not None:
+            self.data_list = data_list  # Use the provided data list
+        elif root is not None:
+            # Load and process data from root directory if data_list is not provided
+            self.graph_df = pd.read_csv(os.path.join(root, 'graphs.csv'))
+            self.nodes_df = pd.read_csv(os.path.join(root, 'nodes.csv'))
+            self.edges_df = pd.read_csv(os.path.join(root, 'edges.csv'))
+            self.data_list = self.process_all()
+        else:
+            raise ValueError("Either a root directory or a data_list must be provided.")
 
-    @property
-    def raw_file_names(self):
-        return ['graphs.csv', 'nodes.csv', 'edges.csv']
+        # Filter data_list based on indices if provided
+        if indices is not None:
+            self.data_list = [self.data_list[i] for i in indices]
 
     def process_all(self):
         data_list = []
@@ -73,12 +94,9 @@ class CustomGraphDataset(Dataset):
             else:
                 edge_attr = None
 
-
-
             if self.graph_level:
                 label_value = self.graph_df[self.graph_df['graph_id'] == graph_id]['label'].values[0]
                 
-                # Check if the label is an integer or a float and cast accordingly
                 if isinstance(label_value, int):
                     y = torch.tensor([label_value], dtype=torch.long)
                 elif isinstance(label_value, float):
@@ -89,7 +107,6 @@ class CustomGraphDataset(Dataset):
             elif self.node_level:
                 label_values = graph_nodes['label'].values
                 
-                # Check if the labels are integers or floats and cast accordingly
                 if issubclass(label_values.dtype.type, int):
                     y = torch.tensor(label_values, dtype=torch.long)
                 elif issubclass(label_values.dtype.type, float):
@@ -97,12 +114,6 @@ class CustomGraphDataset(Dataset):
                 else:
                     raise ValueError(f"Unexpected label types: {label_values.dtype}. Expected int or float.")
 
-
-            # if self.graph_level:
-            #     y = torch.tensor([self.graph_df[self.graph_df['graph_id'] == graph_id]['label'].values[0]], dtype=torch.long)
-            # elif self.node_level:
-            #     y = torch.tensor(graph_nodes['label'].values, dtype=torch.long)
-
             data = Data(x=x, edge_index=edge_index, y=y)
             if edge_attr is not None:
                 data.edge_attr = edge_attr
@@ -111,14 +122,103 @@ class CustomGraphDataset(Dataset):
 
         return data_list
 
-    def len(self):
+    def __len__(self):
         return len(self.data_list)
 
-    def get(self, idx):
+    def __getitem__(self, idx):
         return self.data_list[idx]
 
-    def __getitem__(self, idx):
-        return self.get(idx)
+
+
+
+# class CustomGraphDataset(Dataset):
+#     def __init__(self, root, node_level=False, graph_level=True, node_attr_key='feat', 
+#                  edge_attr_key='feat', transform=None, pre_transform=None):
+#         super(CustomGraphDataset, self).__init__(root, transform, pre_transform)
+#         assert not (node_level and graph_level), "Both node_level and graph_level cannot be True at the same time"
+#         assert node_level or graph_level, "Both node_level and graph_level cannot be False at the same time"
+
+#         self.node_level = node_level
+#         self.graph_level = graph_level
+#         self.node_attr_key = node_attr_key
+#         self.edge_attr_key = edge_attr_key
+
+#         self.graph_df = pd.read_csv(os.path.join(root, 'graphs.csv'))
+#         self.nodes_df = pd.read_csv(os.path.join(root, 'nodes.csv'))
+#         self.edges_df = pd.read_csv(os.path.join(root, 'edges.csv'))
+
+#         self.data_list = self.process_all()
+
+#     @property
+#     def raw_file_names(self):
+#         return ['graphs.csv', 'nodes.csv', 'edges.csv']
+
+#     def process_all(self):
+#         data_list = []
+#         for graph_id in self.graph_df['graph_id'].unique():
+#             graph_nodes = self.nodes_df[self.nodes_df['graph_id'] == graph_id]
+#             graph_edges = self.edges_df[self.edges_df['graph_id'] == graph_id]
+
+#             if self.node_attr_key in graph_nodes.columns and not graph_nodes[self.node_attr_key].isnull().all():
+#                 x = torch.tensor(graph_nodes[self.node_attr_key].values.tolist(), dtype=torch.float)
+#                 if x.ndim == 1:
+#                     x = x.unsqueeze(1)  # Ensure x has shape [num_nodes, *]
+#             else:
+#                 x = None
+
+#             edge_index = torch.tensor(graph_edges[['src_id', 'dst_id']].values.T, dtype=torch.long)
+
+#             if self.edge_attr_key in graph_edges.columns and not graph_edges[self.edge_attr_key].isnull().all():
+#                 edge_attr = torch.tensor(graph_edges[self.edge_attr_key].values.tolist(), dtype=torch.float)
+#             else:
+#                 edge_attr = None
+
+
+
+#             if self.graph_level:
+#                 label_value = self.graph_df[self.graph_df['graph_id'] == graph_id]['label'].values[0]
+                
+#                 # Check if the label is an integer or a float and cast accordingly
+#                 if isinstance(label_value, int):
+#                     y = torch.tensor([label_value], dtype=torch.long)
+#                 elif isinstance(label_value, float):
+#                     y = torch.tensor([label_value], dtype=torch.float)
+#                 else:
+#                     raise ValueError(f"Unexpected label type: {type(label_value)}. Expected int or float.")
+                    
+#             elif self.node_level:
+#                 label_values = graph_nodes['label'].values
+                
+#                 # Check if the labels are integers or floats and cast accordingly
+#                 if issubclass(label_values.dtype.type, int):
+#                     y = torch.tensor(label_values, dtype=torch.long)
+#                 elif issubclass(label_values.dtype.type, float):
+#                     y = torch.tensor(label_values, dtype=torch.float)
+#                 else:
+#                     raise ValueError(f"Unexpected label types: {label_values.dtype}. Expected int or float.")
+
+
+#             # if self.graph_level:
+#             #     y = torch.tensor([self.graph_df[self.graph_df['graph_id'] == graph_id]['label'].values[0]], dtype=torch.long)
+#             # elif self.node_level:
+#             #     y = torch.tensor(graph_nodes['label'].values, dtype=torch.long)
+
+#             data = Data(x=x, edge_index=edge_index, y=y)
+#             if edge_attr is not None:
+#                 data.edge_attr = edge_attr
+
+#             data_list.append(data)
+
+#         return data_list
+
+#     def len(self):
+#         return len(self.data_list)
+
+#     def get(self, idx):
+#         return self.data_list[idx]
+
+#     def __getitem__(self, idx):
+#         return self.get(idx)
 
 class _Hparams:
     def __init__(self, model_type="ClassifierHoldout", optimizer_str="Adam", amsgrad=False, betas=(0.9, 0.999), eps=1e-6, lr=0.001, lr_decay= 0, maximize=False, rho=0.9, weight_decay=0, cv_type="Holdout", split=[0.8,0.1, 0.1], k_folds=5, hl_widths=[32], conv_layer_type='SAGEConv', pooling="AvgPooling", batch_size=32, epochs=1, 
@@ -375,7 +475,8 @@ class _GraphRegressorKFold:
     
     def _initialize_model(self, hparams, dataset):
         if hparams.conv_layer_type.lower() == 'sageconv':
-            return _SAGEConv(dataset.num_node_features, hparams.hl_widths, 1, hparams.pooling).to(self.device)
+            return _SAGEConv(dataset[0].num_node_features, hparams.hl_widths, 1, hparams.pooling).to(self.device)
+            #return _SAGEConv(dataset.num_node_features, hparams.hl_widths, 1, hparams.pooling).to(self.device)
         else:
             raise NotImplementedError
     
@@ -1485,7 +1586,7 @@ class PyG:
         """
 
         import torch
-        from torch.utils.data import random_split, Subset
+        from torch.utils.data import random_split
         train_ratio, val_ratio, test_ratio = split
         assert abs(train_ratio + val_ratio + test_ratio - 1.0) < 1e-6, "Ratios must add up to 1."
         
@@ -1506,9 +1607,10 @@ class PyG:
         val_indices = indices[train_len:train_len + val_len]
         test_indices = indices[train_len + val_len:train_len + val_len + test_len]
 
-        train_dataset = Subset(dataset, train_indices)
-        val_dataset = Subset(dataset, val_indices)
-        test_dataset = Subset(dataset, test_indices)
+        # Create new instances of CustomGraphDataset using the indices
+        train_dataset = CustomGraphDataset(data_list=dataset.data_list, indices=train_indices)
+        val_dataset = CustomGraphDataset(data_list=dataset.data_list, indices=val_indices)
+        test_dataset = CustomGraphDataset(data_list=dataset.data_list, indices=test_indices)
 
         return train_dataset, val_dataset, test_dataset
 

topologicpy/Shell.py

@@ -269,7 +269,7 @@ class Shell():
         return None
 
     @staticmethod
-    def ByFaces(faces: list, tolerance: float = 0.0001):
+    def ByFaces(faces: list, tolerance: float = 0.0001, silent=False):
         """
         Creates a shell from the input list of faces.
 
@@ -279,6 +279,8 @@ class Shell():
             The input list of faces.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -300,7 +302,8 @@ class Shell():
             if Topology.IsInstance(shell, "Shell"):
                 return shell
             else:
-                print("Shell.ByFaces - Error: Could not create shell. Returning None.")
+                if not silent:
+                    print("Shell.ByFaces - Error: Could not create shell. Returning None.")
                 return None
         else:
             return shell
@@ -396,9 +399,11 @@ class Shell():
         topologic_core.Shell
             The creates shell.
         """
+        from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
         from topologicpy.Wire import Wire
         from topologicpy.Face import Face
+        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
 
         if not isinstance(wires, list):
@@ -440,6 +445,24 @@ class Shell():
                         e5 = Edge.ByVertices([e1.StartVertex(), e2.EndVertex()], tolerance=tolerance, silent=silent)
                         faces.append(Face.ByWire(Wire.ByEdges([e1, e5, e4], tolerance=tolerance), tolerance=tolerance))
                         faces.append(Face.ByWire(Wire.ByEdges([e2, e5, e3], tolerance=tolerance), tolerance=tolerance))
+                    elif e3:
+                        verts = [Edge.StartVertex(e1), Edge.EndVertex(e1), Edge.StartVertex(e3), Edge.EndVertex(e3), Edge.StartVertex(e2), Edge.EndVertex(e2)]
+                        verts = Vertex.Fuse(verts, tolerance=tolerance)
+                        w = Wire.ByVertices(verts, close=True)
+                        if Topology.IsInstance(w, "Wire"):
+                            faces.append(Face.ByWire(w, tolerance=tolerance))
+                        else:
+                            if not silent:
+                                print("Shell.ByWires - Warning: Could not create face.")
+                    elif e4:
+                        verts = [Edge.StartVertex(e1), Edge.EndVertex(e1), Edge.StartVertex(e4), Edge.EndVertex(e4), Edge.StartVertex(e2), Edge.EndVertex(e2)]
+                        verts = Vertex.Fuse(verts, tolerance=tolerance)
+                        w = Wire.ByVertices(verts, close=True)
+                        if Topology.IsInstance(w, "Wire"):
+                            faces.append(Face.ByWire(w, tolerance=tolerance))
+                        else:
+                            if not silent:
+                                print("Shell.ByWires - Warning: Could not create face.")
             else:
                 for j in range (len(w1_edges)):
                     e1 = w1_edges[j]
@@ -466,10 +489,30 @@ class Shell():
                         except:
                             faces.append(Face.ByWire(Wire.ByEdges([e1, e3, e2, e4], tolerance=tolerance), tolerance=tolerance))
                     elif e3:
-                            faces.append(Face.ByWire(Wire.ByEdges([e1, e3, e2], tolerance=tolerance), tolerance=tolerance))
+                        verts = [Edge.StartVertex(e1), Edge.EndVertex(e1), Edge.StartVertex(e3), Edge.EndVertex(e3), Edge.StartVertex(e2), Edge.EndVertex(e2)]
+                        verts = Vertex.Fuse(verts, tolerance=tolerance)
+                        w = Wire.ByVertices(verts, close=True)
+                        if Topology.IsInstance(w, "Wire"):
+                            faces.append(Face.ByWire(w, tolerance=tolerance))
+                        else:
+                            if not silent:
+                                print("Shell.ByWires - Warning: Could not create face.")
                     elif e4:
-                            faces.append(Face.ByWire(Wire.ByEdges([e1, e4, e2], tolerance=tolerance), tolerance=tolerance))
-        return Shell.ByFaces(faces, tolerance=tolerance)
+                        verts = [Edge.StartVertex(e1), Edge.EndVertex(e1), Edge.StartVertex(e4), Edge.EndVertex(e4), Edge.StartVertex(e2), Edge.EndVertex(e2)]
+                        verts = Vertex.Fuse(verts, tolerance=tolerance)
+                        w = Wire.ByVertices(verts, close=True)
+                        if Topology.IsInstance(w, "Wire"):
+                            faces.append(Face.ByWire(w, tolerance=tolerance))
+                        else:
+                            if not silent:
+                                print("Shell.ByWires - Warning: Could not create face.")
+
+        shell = Shell.ByFaces(faces, tolerance=tolerance, silent=silent)
+        if shell == None:
+            if not silent:
+                print("Shell.ByWires - Warning: Could not create shell. Returning a cluster of faces instead.")
+            return Cluster.ByTopologies(faces)
+        return shell
 
     @staticmethod
     def ByWiresCluster(cluster, triangulate: bool = True, tolerance: float = 0.0001, silent: bool = False):
@@ -1058,10 +1101,10 @@ class Shell():
 
 
     @staticmethod
-    def ParabolicSurface(origin= None, focalLength=0.125, width: float = 1, length: float = 1, uSides: int = 16, vSides: int = 16,
-                    direction: list = [0, 0, 1], placement: str ="center", mantissa: int = 6, tolerance: float = 0.0001):
+    def Paraboloid(origin= None, focalLength=0.125, width: float = 1, length: float = 1, uSides: int = 16, vSides: int = 16,
+                    direction: list = [0, 0, 1], placement: str ="center", mantissa: int = 6, tolerance: float = 0.0001, silent: bool = False):
         """
-            Creates a parabolic surface.
+            Creates a paraboloid. See https://en.wikipedia.org/wiki/Paraboloid
 
             Parameters
             ----------
@@ -1085,11 +1128,13 @@ class Shell():
                 The desired length of the mantissa. The default is 6.
             tolerance : float , optional
                 The desired tolerance. The default is 0.0001.
+            silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
             
             Returns
             -------
             topologic_core.Shell
-                The created parabolic surface.
+                The created paraboloid.
 
             """
         from topologicpy.Vertex import Vertex
@@ -1197,6 +1242,7 @@ class Shell():
         from topologicpy.Vertex import Vertex
         from topologicpy.Face import Face
         from topologicpy.Topology import Topology
+        
         if not Topology.IsInstance(origin, "Vertex"):
             origin = Vertex.ByCoordinates(0, 0, 0)
         if not Topology.IsInstance(origin, "Vertex"):

topologicpy/Topology.py

@@ -2627,6 +2627,7 @@ class Topology():
                 if ap != None:
                     apertures.append(ap)
             context = Context.ByTopologyParameters(topology, u=0.5, v=0.5, w=0.5)
+            
             for ap in apertures:
                 _ = Aperture.ByTopologyContext(ap, context)
             return topology
@@ -2828,7 +2829,7 @@ class Topology():
                 defaultColor: list = [255,255,255],
                 defaultOpacity: float = 1.0,
                 transposeAxes: bool = True,
-                removeCoplanarFaces: bool = True,
+                removeCoplanarFaces: bool = False,
                 selfMerge: bool = True,
                 mantissa : int = 6,
                 tolerance: float = 0.0001):
@@ -2887,7 +2888,7 @@ class Topology():
     @staticmethod
     def ByOBJPath(objPath,
                   defaultColor: list = [255,255,255], defaultOpacity: float = 1.0,
-                  transposeAxes: bool = True, removeCoplanarFaces: bool = True,
+                  transposeAxes: bool = True, removeCoplanarFaces: bool = False,
                   selfMerge: bool = False,
                   mantissa : int = 6, tolerance: float = 0.0001):
         """
@@ -3122,16 +3123,19 @@ class Topology():
                         selector = Topology.SetDictionary(selector, d)
                         face_selectors.append(selector)
 
-            topology = Cluster.ByTopologies(object_faces, tolerance=tolerance)
-            if selfMerge:
-                topology = Topology.SelfMerge(topology)
-            if removeCoplanarFaces:
-                topology = Topology.RemoveCoplanarFaces(topology, tolerance=tolerance)
-            d = Dictionary.ByKeysValues(['name', 'color', 'opacity'], [object_name, object_color, object_opacity])
-            topology = Topology.SetDictionary(topology, d)
-            if len(face_selectors) > 0:
-                topology = Topology.TransferDictionariesBySelectors(topology, selectors=face_selectors, tranFaces=True, tolerance=tolerance)
-            return_topologies.append(topology)
+            topology = Cluster.ByTopologies(object_faces)
+            if Topology.IsInstance(topology, "Topology"):
+                if selfMerge:
+                    topology = Topology.SelfMerge(topology)
+                if Topology.IsInstance(topology, "Topology"):
+                    if removeCoplanarFaces:
+                        topology = Topology.RemoveCoplanarFaces(topology, tolerance=tolerance)
+                    if Topology.IsInstance(topology, "Topology"):
+                        d = Dictionary.ByKeysValues(['name', 'color', 'opacity'], [object_name, object_color, object_opacity])
+                        topology = Topology.SetDictionary(topology, d)
+                        if len(face_selectors) > 0:
+                            topology = Topology.TransferDictionariesBySelectors(topology, selectors=face_selectors, tranFaces=True, tolerance=tolerance)
+                        return_topologies.append(topology)
         return return_topologies
 
     @staticmethod
@@ -6308,7 +6312,7 @@ class Topology():
                 rot_vertices = [Vertex.ByCoordinates(rot_v) for rot_v in rot_vertices]
                 new_topology = Topology.ReplaceVertices(topology, verticesA=Topology.Vertices(topology), verticesB=rot_vertices)
                 new_topology = Topology.SelfMerge(new_topology, tolerance=tolerance)
-                if len(Dictionary.Keys(d) > 0):
+                if len(Dictionary.Keys(d)) > 0:
                     new_topology = Topology.SetDictionary(new_topology, d)
                 return new_topology
         if len(Dictionary.Keys(d)) > 0:
@@ -7482,10 +7486,13 @@ class Topology():
         """
         from topologicpy.Graph import Graph
         
+        
         if Topology.IsInstance(topology, "Vertex"):
             return []
         if Topology.IsInstance(topology, "Graph"):
             return Graph.Vertices(topology)
+        if topology == None:
+            return None
         return Topology.SubTopologies(topology=topology, subTopologyType="vertex")
     
     @staticmethod
@@ -7875,7 +7882,6 @@ class Topology():
             if Topology.IsInstance(topology, "Cell"):
                 sinkCells = [topology]
             elif hidimSink >= Topology.TypeID("Cell"):
-                print("Transfering Dictionaries to Cells")
                 sinkCells = Topology.Cells(topology)
             _ = Topology.TransferDictionaries(selectors, sinkCells, tolerance=tolerance, numWorkers=numWorkers)
         return topology

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.43'
+__version__ = '0.7.45'

{topologicpy-0.7.43.dist-info → topologicpy-0.7.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.43
+Version: 0.7.45
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: MIT License

{topologicpy-0.7.43.dist-info → topologicpy-0.7.45.dist-info}/RECORD

@@ -1,6 +1,6 @@
 topologicpy/ANN.py,sha256=XAuUjNvDRK1hhXfo82S-zXmnAPZGEdHJMRdfpu0aJ8I,47901
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
-topologicpy/Cell.py,sha256=c6LeEY6-gMNByIHGC_rb2wm9ogg93VhwYK3zJ8IB78U,99798
+topologicpy/Cell.py,sha256=ITQ9EdWEGNKW57EJTewmIhlgk8hk8McM8ZA5oDmubMk,105866
 topologicpy/CellComplex.py,sha256=x474N-lo1krpdIGrWRAFRdDup5a_1V-mLORTS6ZGZ7M,48227
 topologicpy/Cluster.py,sha256=TZXuxzdaUr6OHSWnjWpjCOMlVj6YHBH8aUVbDVsncVA,54999
 topologicpy/Color.py,sha256=UlmRcCSOhqcM_OyMWz4t3Kr75KcgXDhz3uctAJ2n7Ic,18031
@@ -8,28 +8,28 @@ topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
 topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
 topologicpy/Dictionary.py,sha256=KqJ29YyE23Y3Xc6XmKLSCZXRfBvm-OEOxlMZ4dt-rfM,27094
 topologicpy/Edge.py,sha256=vhYHkobSLGSWV-oe2oJFFDobqFToDyb7s71yQ840AAA,65166
-topologicpy/EnergyModel.py,sha256=ni0H1JgvLl1-q90yK9Sm1qj5P1fTuidlimEIcwuj6qE,53287
-topologicpy/Face.py,sha256=d1Im4ogxuaVmZyb6hgv5muwQwahLtGzOar_a3og1a_I,115376
-topologicpy/Graph.py,sha256=p3VoVH6yygNV2wwzpsi4tm6yOfwRbtmsbnsAu2opLjQ,393517
+topologicpy/EnergyModel.py,sha256=XcCP55VW5WHDIIKcURijmBOZEgNUDEn_V9h5EejkntA,53876
+topologicpy/Face.py,sha256=pn0LGusTPKLrHEMhY94_Bs3rc4wUpIyEqyW9q-ftdG0,115379
+topologicpy/Graph.py,sha256=3TB0bfESpBsGnI7CspeeZqC5v1hVY9SwAgvczFJxT_4,401612
 topologicpy/Grid.py,sha256=3-sn7CHWGcXk18XCnHjsUttNJTWwmN63g_Insj__p04,18218
 topologicpy/Helper.py,sha256=i-AfI29NMsZXBaymjilfvxQbuS3wpYbpPw4RWu1YCHs,16358
 topologicpy/Honeybee.py,sha256=vcBECJlgWVjNNdD9ZmjNik_pA1Y_ZNoOorsQb2CiyGA,21965
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=YvtF7RYUMATEZ8iHwFwK_MOxEDyARby2DTI2CCK6-cI,19694
-topologicpy/Plotly.py,sha256=U6Lo7hyDoStRKQXqlhb2LM-rR_bfBulxetRT2wMBmhI,105391
+topologicpy/Plotly.py,sha256=Q1jrHXFFNwzA6lMa5V0sH7I5p5KRp5y_WohDnhIlB2E,105354
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
-topologicpy/PyG.py,sha256=Dd0fiEbM_KR-sEHKCodmURBFFvckB6j7x4oBcCC5Q2o,102171
-topologicpy/Shell.py,sha256=NZyHYTvV0pXx18AoMbVs8y-7if8teETItv5ZOJq6gzE,84672
+topologicpy/PyG.py,sha256=0yeECsMz-dqhhZSv52s_xPCO_3BcEXUK7z1YFDN9qoo,106987
+topologicpy/Shell.py,sha256=aKdWIAqmLKPyi80f2PtH3_1iMfQRW0Eklbqol9cOPWM,87601
 topologicpy/Speckle.py,sha256=rUS6PCaxIjEF5_fUruxvMH47FMKg-ohcoU0qAUb-yNM,14267
 topologicpy/Sun.py,sha256=InnKtX8eKwtAgcScuABH6yp0ljmWh5m_fDR4-n3jJMY,36869
-topologicpy/Topology.py,sha256=5KGQ8jSiURMk9syoMLc3mrIONCfj_pfvCfHTKgPcLOM,366047
+topologicpy/Topology.py,sha256=XyXMuw1jTFdHJbuYNub_ngr9mFHmKxejUR7fe6denlk,366314
 topologicpy/Vector.py,sha256=WQQUbwrg7VKImtxuBUi2i-FRiPT77WlrzLP05gdXKM8,33079
 topologicpy/Vertex.py,sha256=EQdVYHmW85_pZdHZB3N8pEi0GiadCCkF3z_oqohA7B0,71161
 topologicpy/Wire.py,sha256=9EJE0Iq3nGz5X7Suy6xxjmuOpfV49By6WH98UAL_7m4,153532
 topologicpy/__init__.py,sha256=D7ky87CAQMiS2KE6YLvcTLkTgA2PY7rASe6Z23pjp9k,872
-topologicpy/version.py,sha256=7JOl9BjjPK0ib5M5rAuj9I5xjEoYF6YsFAS_dvAYEzg,23
-topologicpy-0.7.43.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.43.dist-info/METADATA,sha256=NCprd1lCZf1afHBHxA5uol5btFYvJFZeiIdoIJtQ5aI,10916
-topologicpy-0.7.43.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-topologicpy-0.7.43.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.43.dist-info/RECORD,,
+topologicpy/version.py,sha256=M-0kJd97wNsL6CZrI2htV9HFPeXVaDWIQkIhzYnuc-Q,23
+topologicpy-0.7.45.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
+topologicpy-0.7.45.dist-info/METADATA,sha256=4AAcme8ANBpGbJpb0G9Rw12I7lL95TmhfYP_GTz9sK4,10916
+topologicpy-0.7.45.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+topologicpy-0.7.45.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.45.dist-info/RECORD,,

{topologicpy-0.7.43.dist-info → topologicpy-0.7.45.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.2.0)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any