topologicpy 0.7.44__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/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/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

@@ -2829,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):
@@ -2888,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):
         """
@@ -3123,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
@@ -7483,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

topologicpy/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.44
+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.44.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
@@ -9,27 +9,27 @@ 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=XcCP55VW5WHDIIKcURijmBOZEgNUDEn_V9h5EejkntA,53876
-topologicpy/Face.py,sha256=d1Im4ogxuaVmZyb6hgv5muwQwahLtGzOar_a3og1a_I,115376
-topologicpy/Graph.py,sha256=p3VoVH6yygNV2wwzpsi4tm6yOfwRbtmsbnsAu2opLjQ,393517
+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=0yeECsMz-dqhhZSv52s_xPCO_3BcEXUK7z1YFDN9qoo,106987
-topologicpy/Shell.py,sha256=NZyHYTvV0pXx18AoMbVs8y-7if8teETItv5ZOJq6gzE,84672
+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=RFZPKx15qM53skLavdMwL_YnJkDIinOnz3CLAY5OsWE,366001
+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=2Sw5dX1m7XzP13Ernw7oNdPR5WsUzOMJ7VZ-QyJpf9o,23
-topologicpy-0.7.44.dist-info/LICENSE,sha256=BRNw73R2WdDBICtwhI3wm3cxsaVqLTAGuRwrTltcfxs,1068
-topologicpy-0.7.44.dist-info/METADATA,sha256=N7KPudecCpJl9CdmpNEfoLiXYGpxcXZwegs6AvC1HTo,10916
-topologicpy-0.7.44.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-topologicpy-0.7.44.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.44.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.44.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