topologicpy 0.4.81__py3-none-any.whl → 0.4.83__py3-none-any.whl

topologicpy/Graph.py

@@ -4315,6 +4315,87 @@ class Graph:
             return None
         return graph.GetGUID()
 
+    @staticmethod
+    def IncomingEdges(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool=False, tolerance: float=0.0001) -> list:
+        """
+        Returns the incoming edges connected to a vertex. An edge is considered incoming if its end vertex is
+        coincident with the input vertex.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        vertex : topologic.Vertex
+            The input vertex.
+        directed : bool , optional
+            If set to True, the graph is considered to be directed. Otherwise, it will be considered as an unidrected graph. The default is False.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            The list of incoming edges
+
+        """
+        from topologicpy.Edge import Edge
+        if not isinstance(graph, topologic.Graph):
+            print("Graph.IncomingEdges - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        if not isinstance(vertex, topologic.Vertex):
+            print("Graph.IncomingEdges - Error: The input vertex parameter is not a valid vertex. Returning None.")
+            return None
+        
+        edges = Graph.Edges(graph, [vertex])
+        if directed == False:
+            return edges
+        incoming_edges = []
+        for edge in edges:
+            ev = Edge.EndVertex(edge)
+            if Vertex.Distance(vertex, ev) < tolerance:
+                incoming_edges.append(edge)
+        return incoming_edges
+    
+    @staticmethod
+    def IncomingVertices(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool=False, tolerance: float=0.0001) -> list:
+        """
+        Returns the incoming vertices connected to a vertex. A vertex is considered incoming if it is an adjacent vertex to the input vertex
+        and the the edge connecting it to the input vertex is an incoming edge.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        vertex : topologic.Vertex
+            The input vertex.
+        directed : bool , optional
+            If set to True, the graph is considered to be directed. Otherwise, it will be considered as an unidrected graph. The default is False.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            The list of incoming vertices
+
+        """
+        from topologicpy.Edge import Edge
+        if not isinstance(graph, topologic.Graph):
+            print("Graph.IncomingVertices - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        if not isinstance(vertex, topologic.Vertex):
+            print("Graph.IncomingVertices - Error: The input vertex parameter is not a valid vertex. Returning None.")
+            return None
+        
+        if directed == False:
+            return Graph.AdjacentVertices(graph, vertex)
+        incoming_edges = Graph.IncomingEdges(graph, vertex, directed=directed, tolerance=tolerance)
+        incoming_vertices = []
+        for edge in incoming_edges:
+            sv = Edge.StartVertex(edge)
+            incoming_vertices.append(Graph.NearestVertex(graph, sv))
+        return incoming_vertices
+    
     @staticmethod
     def IsBipartite(graph, tolerance=0.0001):
         """
@@ -5142,7 +5223,144 @@ class Graph:
             print("Graph.Order - Error: The input graph is not a valid graph. Returning None.")
             return None
         return len(Graph.Vertices(graph))
+    
+    @staticmethod
+    def OutgoingEdges(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool=False, tolerance: float=0.0001) -> list:
+        """
+        Returns the outgoing edges connected to a vertex. An edge is considered outgoing if its start vertex is
+        coincident with the input vertex.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        vertex : topologic.Vertex
+            The input vertex.
+        directed : bool , optional
+            If set to True, the graph is considered to be directed. Otherwise, it will be considered as an unidrected graph. The default is False.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            The list of outgoing edges
 
+        """
+        from topologicpy.Edge import Edge
+        if not isinstance(graph, topologic.Graph):
+            print("Graph.IncomingEdges - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        if not isinstance(vertex, topologic.Vertex):
+            print("Graph.IncomingEdges - Error: The input vertex parameter is not a valid vertex. Returning None.")
+            return None
+        
+        edges = Graph.Edges(graph, [vertex])
+        if directed == False:
+            return edges
+        outgoing_edges = []
+        for edge in edges:
+            sv = Edge.StartVertex(edge)
+            if Vertex.Distance(vertex, sv) < tolerance:
+                outgoing_edges.append(edge)
+        return outgoing_edges
+    
+    @staticmethod
+    def OutgoingVertices(graph: topologic.Graph, vertex: topologic.Vertex, directed: bool=False, tolerance: float=0.0001) -> list:
+        """
+        Returns the list of outgoing vertices connected to a vertex. A vertex is considered outgoing if it is an adjacent vertex to the input vertex
+        and the the edge connecting it to the input vertex is an outgoing edge.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        vertex : topologic.Vertex
+            The input vertex.
+        directed : bool , optional
+            If set to True, the graph is considered to be directed. Otherwise, it will be considered as an unidrected graph. The default is False.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            The list of incoming vertices
+
+        """
+        from topologicpy.Edge import Edge
+        if not isinstance(graph, topologic.Graph):
+            print("Graph.OutgoingVertices - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        if not isinstance(vertex, topologic.Vertex):
+            print("Graph.OutgoingVertices - Error: The input vertex parameter is not a valid vertex. Returning None.")
+            return None
+        
+        if directed == False:
+            return Graph.AdjacentVertices(graph, vertex)
+        outgoing_edges = Graph.OutgoingEdges(graph, vertex, directed=directed, tolerance=tolerance)
+        outgoing_vertices = []
+        for edge in outgoing_edges:
+            ev = Edge.EndVertex(edge)
+            outgoing_vertices.append(Graph.NearestVertex(graph, ev))
+        return outgoing_vertices
+    
+    @staticmethod
+    def PageRank(graph, alpha=0.85, maxIterations=100, normalize=True, directed=False, mantissa=6, tolerance=0.0001):
+        """
+        Calculates PageRank scores for nodes in a directed graph. see https://en.wikipedia.org/wiki/PageRank.
+
+        Parameters
+        ----------
+        graph : topologic.Graph
+            The input graph.
+        alpha : float , optional
+            The damping (dampening) factor. The default is 0.85. See https://en.wikipedia.org/wiki/PageRank.
+        maxIterations : int , optional
+            The maximum number of iterations to calculate the page rank. The default is 100.
+        normalize : bool , optional
+            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.
+        mantissa : int , optional
+            The desired length of the mantissa.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            The list of page ranks for the vertices in the graph.
+        """
+        from topologicpy.Helper import Helper
+
+        vertices = Graph.Vertices(graph)
+        num_vertices = len(vertices)
+        if num_vertices < 1:
+            print("Graph.PageRank - Error: The input graph parameter has no vertices. Returning None")
+            return None
+        initial_score = 1.0 / num_vertices
+        scores = [initial_score for vertex in vertices]
+        for _ in range(maxIterations):
+            new_scores = [0 for vertex in vertices]
+            for i, vertex in enumerate(vertices):
+                incoming_score = 0
+                for incoming_vertex in Graph.IncomingVertices(graph, vertex, directed=directed):
+                    if len(Graph.IncomingVertices(graph, incoming_vertex, directed=directed)) > 0:
+                        incoming_score += scores[Vertex.Index(incoming_vertex, vertices)] / len(Graph.IncomingVertices(graph, incoming_vertex, directed=directed))
+                new_scores[i] = alpha * incoming_score + (1 - alpha) / num_vertices
+
+            # Check for convergence
+            if all(abs(new_scores[i] - scores[i]) < tolerance for i in range(len(vertices))):
+                break
+
+            scores = new_scores
+        if normalize == True:
+            scores = Helper.Normalize(scores, mantissa=mantissa)
+        else:
+            scores = [round(x, mantissa) for x in scores]
+        return scores
+    
     @staticmethod
     def Path(graph, vertexA, vertexB):
         """
@@ -5835,7 +6053,7 @@ class Graph:
         return Graph.ByVerticesEdges(dictionary['vertices'], dictionary['edges'])
     
     @staticmethod
-    def VertexDegree(graph, vertex):
+    def VertexDegree(graph : topologic.Graph, vertex: topologic.Vertex, edgeKey: str=None, tolerance: float=0.0001):
         """
         Returns the degree of the input vertex. See https://en.wikipedia.org/wiki/Degree_(graph_theory).
 
@@ -5843,8 +6061,13 @@ class Graph:
         ----------
         graph : topologic.Graph
             The input graph.
-        vertices : topologic.Vertex
+        vertex : topologic.Vertex
             The input vertex.
+        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.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
 
         Returns
         -------
@@ -5852,13 +6075,28 @@ class Graph:
             The degree of the input vertex.
 
         """
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        import numbers
+
         if not isinstance(graph, topologic.Graph):
             print("Graph.VertexDegree - Error: The input graph is not a valid graph. Returning None.")
             return None
         if not isinstance(vertex, topologic.Vertex):
             print("Graph.VertexDegree - Error: The input vertex is not a valid vertex. Returning None.")
             return None
-        return graph.VertexDegree(vertex)
+        if not isinstance(edgeKey, str):
+            edgeKey = ""
+        edges = Graph.Edges(graph, [vertex], tolerance=tolerance)
+        degree = 0
+        for edge in edges:
+            d = Topology.Dictionary(edge)
+            value = Dictionary.ValueAtKey(d, edgeKey)
+            if isinstance(value, numbers.Number):
+                degree += value
+            else:
+                degree += 1
+        return degree
     
     @staticmethod
     def Vertices(graph):

topologicpy/__init__.py

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

{topologicpy-0.4.81.dist-info → topologicpy-0.4.83.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.4.81
+Version: 0.4.83
 Summary: An Advanced Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 Project-URL: Homepage, https://github.com/wassimj/TopologicPy

{topologicpy-0.4.81.dist-info → topologicpy-0.4.83.dist-info}/RECORD

@@ -9,7 +9,7 @@ topologicpy/Dictionary.py,sha256=vGhiXPu7e7GsgQyTsX6rZBncnnrDlcYfM9xRb9h-l3U,247
 topologicpy/Edge.py,sha256=lMO4TSzN3AJNgS5Vfvl0DBY-aMn8S82xT4TXs7LdUnc,45644
 topologicpy/EnergyModel.py,sha256=WsK40w0eO6WswV6JxYztvX6zBFwTNFvDHOScXxACf08,51760
 topologicpy/Face.py,sha256=y3yWBEI4TlXJu-eOFHOgeoiZl_hGxev3jVE6T4cRPPs,93600
-topologicpy/Graph.py,sha256=fR-INihwPVS9EIJElBFUIAu5z_vYKBeGLb1xrb8_Vk4,287314
+topologicpy/Graph.py,sha256=ne0TNs-NlboFqn_cX5LDbzSFa_7JqIsnJBVtMtw5bEQ,297966
 topologicpy/Grid.py,sha256=q6uAs8MGbdteYNbjqRjqlhFMquYAvSngwzxsFl9-338,17371
 topologicpy/Helper.py,sha256=nG9v3_v4XhPH0HM1lNkLqJ_z1LIjxsugCu_HxG0voYA,13680
 topologicpy/Honeybee.py,sha256=ygiGMS7u-YQJWpK2CmkBuJu1DBABVUmpMdg9HewOhN4,20349
@@ -23,7 +23,7 @@ topologicpy/Topology.py,sha256=7JRQhi7xaExb6BHZxrr13ddSgiflaT_tooxY8_tjgDA,28775
 topologicpy/Vector.py,sha256=57ZoYLd3chEQhjN8Sf1Wv_UR3klltLoaT8TQN0kP-f8,22166
 topologicpy/Vertex.py,sha256=A7hCI-WpHaemow4eDiaqVhZ0ekgifXcWFpa-82txwYM,55187
 topologicpy/Wire.py,sha256=gMqOqNOmph2Elup6j8bNrorBZfCScVChjTvq03rB6NA,133812
-topologicpy/__init__.py,sha256=5gBXJEnZSkDphJspvkkNvUYZe5NrO55EHCtilpPIoGs,1445
+topologicpy/__init__.py,sha256=AVnRhV2NJfG_1EgkMS7jGdBkJJbAmOor1SlmNNEzWJU,1445
 topologicpy/bin/linux/topologic/__init__.py,sha256=XlFReDf3FWlYdM9uXtanYPIafgPb6GVTQczS_xJAXD0,60
 topologicpy/bin/linux/topologic/libTKBO-6bdf205d.so.7.7.0,sha256=ANok9DQKcnWcLd9T_LAt-i-X4nsYYy16q9kQlcTre1E,2996488
 topologicpy/bin/linux/topologic/libTKBRep-2960a069.so.7.7.0,sha256=OJ3XesL79du8LeBHrsleGPXub6OpJdOilxha0mwjqQo,1378768
@@ -84,8 +84,8 @@ topologicpy/bin/windows/topologic/topologic.cp310-win_amd64.pyd,sha256=F0sPLuMpD
 topologicpy/bin/windows/topologic/topologic.cp311-win_amd64.pyd,sha256=aBAJQj3OmJ58MOAF1ZIFybL_5fFK7FNR9hrIps6b6pc,1551872
 topologicpy/bin/windows/topologic/topologic.cp38-win_amd64.pyd,sha256=aLgNf54nbJmGc7Tdmkuy-V0m6B9zLxabIbpRwAy7cBA,1551360
 topologicpy/bin/windows/topologic/topologic.cp39-win_amd64.pyd,sha256=_8cp205hiRxkFHtzQQOweA4DhCPk8caH4kTVLWGQeVw,1411584
-topologicpy-0.4.81.dist-info/LICENSE,sha256=RUmXeeqj63bBySLJjEfhwb9OE7M8h9K6HuOBF3ASVyI,35697
-topologicpy-0.4.81.dist-info/METADATA,sha256=biyhimTuB8q6I7xWQP9TxTO8Jr45dYVhEx8tPN-2wVs,7252
-topologicpy-0.4.81.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-topologicpy-0.4.81.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.4.81.dist-info/RECORD,,
+topologicpy-0.4.83.dist-info/LICENSE,sha256=RUmXeeqj63bBySLJjEfhwb9OE7M8h9K6HuOBF3ASVyI,35697
+topologicpy-0.4.83.dist-info/METADATA,sha256=wXCjKPnzNnIzC1Z_5o0cYk49HHe5ZWX6x5kZfu_PZew,7252
+topologicpy-0.4.83.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+topologicpy-0.4.83.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.4.83.dist-info/RECORD,,