topologicpy 0.7.15__py3-none-any.whl → 0.7.18__py3-none-any.whl

topologicpy/Graph.py

@@ -152,10 +152,10 @@ class WorkerProcess(Process):
         destinations = [Topology.ByBREPString(s) for s in self.destinations]
         for i in range(len(sources)):
             source = sources[i]
-            index_b = Vertex.Index(source, destinations)
+            index_b = Vertex.Index(source, destinations, tolerance=self.tolerance)
             for j in range(len(destinations)):
                 destination = destinations[j]
-                index_a = Vertex.Index(destination, sources)
+                index_a = Vertex.Index(destination, sources, tolerance=self.tolerance)
                 if self.used[i + self.start_index][j] == 1 or self.used[j][i + self.start_index]:
                     continue
                 if Vertex.Distance(source, destination) > self.tolerance:
@@ -269,6 +269,88 @@ class _DrawTree(object):
         return self.__str__()
 
 class Graph:
+    def AdjacencyDictionary(graph, vertexLabelKey: str = "label", edgeKey: str = "Length", reverse: bool = False, mantissa: int = 6):
+        """
+        Returns the adjacency dictionary of the input Graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertexLabelKey : str , optional
+            The returned vertices are labelled according to the dictionary values stored under this key.
+            If the vertexLabelKey does not exist, it will be created and the vertices are labelled numerically and stored in the vertex dictionary under this key. The default is "label".
+        edgeWeightKey : str , optional
+            If set, the edges' dictionaries will be searched for this key to set their weight. If the key is set to "length" (case insensitive), the length of the edge will be used as its weight. If set to None, a weight of 1 will be used. The default is "Length".
+        reverse : bool , optional
+                If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. The default is False.
+        mantissa : int , optional
+                The desired length of the mantissa. The default is 6.
+
+        Returns
+        -------
+        dict
+            The adjacency dictionary.
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+        from topologicpy.Helper import Helper
+
+        if not Topology.IsInstance(graph, "Graph"):
+            print("Graph.AdjacencyDictionary - Error: The input graph is not a valid graph. Returning None.")
+            return None
+        if not isinstance(vertexLabelKey, str):
+            print("Graph.AdjacencyDictionary - Error: The input vertexLabelKey is not a valid string. Returning None.")
+            return None
+        vertices = Graph.Vertices(graph)
+        labels = []
+        n = max(len(str(len(vertices))), 3)
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            value = Dictionary.ValueAtKey(d, vertexLabelKey)
+            if value == None:
+                value = str(i).zfill(n)
+            if d == None:
+                d = Dictionary.ByKeyValue(vertexLabelKey, value)
+            else:
+                d = Dictionary.SetValueAtKey(d, vertexLabelKey, value)
+            v = Topology.SetDictionary(v, d)
+            labels.append(value)
+        vertices = Helper.Sort(vertices, labels)
+        labels.sort()
+        if reverse == True:
+            vertices.reverse()
+            labels.reverse()
+        order = len(vertices)
+        adjDict = {}
+        for i in range(order):
+            v = Graph.NearestVertex(graph, vertices[i])
+            vertex_label = labels[i]
+            adjVertices = Graph.AdjacentVertices(graph, v)
+            temp_list = []
+            for adjVertex in adjVertices:
+                if edgeKey == None:
+                    weight = 1
+                elif "length" in edgeKey.lower():
+                    edge = Graph.Edge(graph, v, adjVertex)
+                    weight = Edge.Length(edge, mantissa=mantissa)
+                else:
+                    edge = Graph.Edge(graph, v, adjVertex)
+                    weight = Dictionary.ValueAtKey(Topology.Dictionary(edge), edgeKey)
+                    if weight == None:
+                        weight = Edge.Length(edge, mantissa=mantissa)
+                    else:
+                        weight = round(weight, mantissa)
+                adjIndex = Vertex.Index(adjVertex, vertices)
+                adjLabel = labels[adjIndex]
+                if not adjIndex == None:
+                    temp_list.append((adjLabel, weight))
+            temp_list.sort()
+            adjDict[vertex_label] = temp_list
+        return adjDict
+    
     @staticmethod
     def AdjacencyMatrix(graph, vertexKey=None, reverse=False, edgeKeyFwd=None, edgeKeyBwd=None, bidirKey=None, bidirectional=True, useEdgeIndex=False, useEdgeLength=False, tolerance=0.0001):
         """
@@ -279,13 +361,13 @@ class Graph:
         graph : topologic_core.Graph
             The input graph.
         vertexKey : str , optional
-            If set, the returned list of vertices is sorted according to the dicitonary values stored under this key. The default is None.
+            If set, the returned list of vertices is sorted according to the dictionary values stored under this key. The default is None.
         reverse : bool , optional
             If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. The default is False.
         edgeKeyFwd : str , optional
-            If set, the value at this key in the connecting edge from start vertex to end verrtex (forward) will be used instead of the value 1. The default is None. useEdgeIndex and useEdgeLength override this setting.
+            If set, the value at this key in the connecting edge from start vertex to end vertex (forward) will be used instead of the value 1. The default is None. useEdgeIndex and useEdgeLength override this setting.
         edgeKeyBwd : str , optional
-            If set, the value at this key in the connecting edge from end vertex to start verrtex (backward) will be used instead of the value 1. The default is None. useEdgeIndex and useEdgeLength override this setting.
+            If set, the value at this key in the connecting edge from end vertex to start vertex (backward) will be used instead of the value 1. The default is None. useEdgeIndex and useEdgeLength override this setting.
         bidirKey : bool , optional
             If set to True or False, this key in the connecting edge will be used to determine is the edge is supposed to be bidirectional or not. If set to None, the input variable bidrectional will be used instead. The default is None
         bidirectional : bool , optional
@@ -363,9 +445,10 @@ class Graph:
             if useEdgeLength:
                 valueFwd = Edge.Length(edge)
                 valueBwd = Edge.Length(edge)
-            matrix[svi][evi] = valueFwd
-            if bidir:
-                matrix[evi][svi] = valueBwd
+            if not svi == None and not evi == None:
+                matrix[svi][evi] = valueFwd
+                if bidir:
+                    matrix[evi][svi] = valueBwd
         return matrix
     
     @staticmethod
@@ -378,7 +461,7 @@ class Graph:
         graph : topologic_core.Graph
             The input graph.
         vertexKey : str , optional
-            If set, the returned list of vertices is sorted according to the dicitonary values stored under this key. The default is None.
+            If set, the returned list of vertices is sorted according to the dictionary values stored under this key. The default is None.
         reverse : bool , optional
             If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. The default is False.
         tolerance : float , optional
@@ -433,7 +516,7 @@ class Graph:
         edge : topologic_core.Edge
             The input edge.
         transferDictionaries : bool, optional
-            If set to True, the dictionaries of the edge and its vertices are transfered to the graph.
+            If set to True, the dictionaries of the edge and its vertices are transferred to the graph.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -1521,7 +1604,7 @@ class Graph:
         edgeFeaturesHeader : str , optional
             The column header string used to specify the features of edges. The default is "feat".
         edgeFeaturesKeys : list , optional
-            The list of dicitonary keys to use to index the edge features. The length of this list must match the length of edge features. The default is [].
+            The list of dictionary keys to use to index the edge features. The length of this list must match the length of edge features. The default is [].
         nodeIDHeader : str , optional
             The column header string used to specify the id of nodes. The default is "node_id".
         nodeLabelHeader : str , optional
@@ -1898,7 +1981,11 @@ class Graph:
 
 
     @staticmethod
-    def ByIFCFile(file, includeTypes=[], excludeTypes=[], includeRels=[], excludeRels=[], xMin=-0.5, yMin=-0.5, zMin=-0.5, xMax=0.5, yMax=0.5, zMax=0.5):
+    def ByIFCFile(file, includeTypes: list = [], excludeTypes: list = [],
+                  includeRels: list = [], excludeRels: list = [],
+                  xMin: float = -0.5, yMin: float = -0.5, zMin: float = -0.5,
+                  xMax: float = 0.5, yMax: float = 0.5, zMax: float = 0.5,
+                  tolerance: float = 0.0001):
         """
         Create a Graph from an IFC file. This code is partially based on code from Bruno Postle.
 
@@ -1926,6 +2013,8 @@ class Graph:
             The desired maximum value to assign for a vertex's Y coordinate. The default is 0.5.
         zMax : float, optional
             The desired maximum value to assign for a vertex's Z coordinate. The default is 0.5.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
         
         Returns
         -------
@@ -2094,19 +2183,21 @@ class Graph:
                 if source:
                     sv = vertexAtKeyValue(vertices, key="id", value=source.id())
                     if sv:
-                        si = Vertex.Index(sv, vertices)
-                        for destination in destinations:
-                            if destination == None:
-                                continue
-                            ev = vertexAtKeyValue(vertices, key="id", value=destination.id())
-                            if ev:
-                                ei = Vertex.Index(ev, vertices)
-                                if not([si,ei] in tuples or [ei,si] in tuples):
-                                    tuples.append([si,ei])
-                                    e = Edge.ByVertices([sv,ev])
-                                    d = Dictionary.ByKeysValues(["id", "name", "type"], [ifc_rel.id(), ifc_rel.Name, ifc_rel.is_a()])
-                                    e = Topology.SetDictionary(e, d)
-                                    edges.append(e)
+                        si = Vertex.Index(sv, vertices, tolerance=tolerance)
+                        if not si == None:
+                            for destination in destinations:
+                                if destination == None:
+                                    continue
+                                ev = vertexAtKeyValue(vertices, key="id", value=destination.id())
+                                if ev:
+                                    ei = Vertex.Index(ev, vertices, tolerance=tolerance)
+                                    if not ei == None:
+                                        if not([si,ei] in tuples or [ei,si] in tuples):
+                                            tuples.append([si,ei])
+                                            e = Edge.ByVertices([sv,ev])
+                                            d = Dictionary.ByKeysValues(["id", "name", "type"], [ifc_rel.id(), ifc_rel.Name, ifc_rel.is_a()])
+                                            e = Topology.SetDictionary(e, d)
+                                            edges.append(e)
             return edges
         
         ifc_types = IFCObjectTypes(file)
@@ -4811,7 +4902,7 @@ class Graph:
                        nodeTrainMaskHeader="train_mask", nodeValidateMaskHeader="val_mask", nodeTestMaskHeader="test_mask",
                        nodeMaskKey=None,
                        nodeTrainRatio=0.8, nodeValidateRatio=0.1, nodeTestRatio=0.1,
-                       mantissa=6, overwrite=False):
+                       mantissa=6, tolerance=0.0001, overwrite=False):
         """
         Exports the input graph into a set of CSV files compatible with DGL.
 
@@ -4894,6 +4985,8 @@ class Graph:
             This value is ignored if an nodeMaskKey is foud.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
         overwrite : bool , optional
             If set to True, any existing files are overwritten. Otherwise, the input list of graphs is appended to the end of each file. The default is False.
 
@@ -5138,14 +5231,15 @@ class Graph:
                 else:
                     edge_features = str(round(float(Dictionary.ValueAtKey(ed, edge_feature_key)), mantissa))
             # Get the Source and Destination vertex indices
-            src = Vertex.Index(Edge.StartVertex(edge), vertices)
-            dst = Vertex.Index(Edge.EndVertex(edge), vertices)
-            single_edge_data = [graph_id, src, dst, edge_label, train_mask, validate_mask, test_mask, edge_features]
-            edge_data.append(single_edge_data)
-
-            if bidirectional == True:
+            src = Vertex.Index(Edge.StartVertex(edge), vertices, tolerance=tolerance)
+            dst = Vertex.Index(Edge.EndVertex(edge), vertices, tolerance=tolerance)
+            if not src == None and not dst == None:
                 single_edge_data = [graph_id, src, dst, edge_label, train_mask, validate_mask, test_mask, edge_features]
                 edge_data.append(single_edge_data)
+
+                if bidirectional == True:
+                    single_edge_data = [graph_id, src, dst, edge_label, train_mask, validate_mask, test_mask, edge_features]
+                    edge_data.append(single_edge_data)
         df = pd.DataFrame(edge_data, columns=edge_columns)
 
         if graph_id == 0:
@@ -5167,7 +5261,8 @@ class Graph:
                     defaultVertexColor: str = "black", defaultVertexSize: float = 3,
                     vertexLabelKey: str = None, vertexColorKey: str = None, vertexSizeKey: str = None, 
                     defaultEdgeColor: str = "black", defaultEdgeWeight: float = 1, defaultEdgeType: str = "undirected",
-                    edgeLabelKey: str = None, edgeColorKey: str = None, edgeWeightKey: str = None, overwrite: bool = False, mantissa: int = 6):
+                    edgeLabelKey: str = None, edgeColorKey: str = None, edgeWeightKey: str = None,
+                    overwrite: bool = False, mantissa: int = 6, tolerance: float = 0.0001):
         """
         Exports the input graph to a Graph Exchange XML (GEXF) file format. See https://gexf.net/
 
@@ -5215,6 +5310,8 @@ class Graph:
             If set to True, any existing file is overwritten. Otherwise, it is not. The default is False.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
 
         Returns
         -------
@@ -5487,20 +5584,20 @@ class Graph:
             edge_dict['weight'] = edge_weight
 
             
-            sv = g_vertices[Vertex.Index(Edge.StartVertex(edge), g_vertices)]
-            ev = g_vertices[Vertex.Index(Edge.EndVertex(edge), g_vertices)]
-            svid = Vertex.Index(sv, g_vertices)
-            edge_dict['source'] = svid
-            evid = Vertex.Index(ev, g_vertices)
-            edge_dict['target'] = evid
-            
-            edge_label = "Edge "+str(svid)+"-"+str(evid)
-            if isinstance(edgeLabelKey, str):
-                edge_label = Dictionary.ValueAtKey(d, edgeLabelKey)
-            if not isinstance(edge_label, str):
+            sv = g_vertices[Vertex.Index(Edge.StartVertex(edge), g_vertices, tolerance=tolerance)]
+            ev = g_vertices[Vertex.Index(Edge.EndVertex(edge), g_vertices, tolerance=tolerance)]
+            svid = Vertex.Index(sv, g_vertices, tolerance=tolerance)
+            evid = Vertex.Index(ev, g_vertices, tolerance=tolerance)
+            if not svid == None and not evid == None:
+                edge_dict['source'] = svid
+                edge_dict['target'] = evid
                 edge_label = "Edge "+str(svid)+"-"+str(evid)
-            edge_dict['label'] = edge_label
-            edges[(str(svid), str(evid))] = edge_dict
+                if isinstance(edgeLabelKey, str):
+                    edge_label = Dictionary.ValueAtKey(d, edgeLabelKey)
+                if not isinstance(edge_label, str):
+                    edge_label = "Edge "+str(svid)+"-"+str(evid)
+                edge_dict['label'] = edge_label
+                edges[(str(svid), str(evid))] = edge_dict
 
         create_gexf_file(nodes, edges, defaultEdgeType, node_attributes, edge_attributes, path)
         return True
@@ -5596,6 +5693,8 @@ class Graph:
             The desired maximum number of iterations to solve the forces in the 'spring' mode. The default is 50.
         rootVertex : topologic_core.Vertex , optional
             The desired vertex to use as the root of the tree and radial layouts.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
 
         Returns
         -------
@@ -5725,9 +5824,12 @@ class Graph:
             Returns:
                 A numpy array representing the adjacency matrix.
             """
-
+            from topologicpy.Helper import Helper
             # Get the number of nodes from the edge list.
-            num_nodes = max([max(edge) for edge in edge_list]) + 1
+            flat_list = Helper.Flatten(edge_list)
+            flat_list = [x for x in flat_list if not x == None]
+            num_nodes = max(flat_list) + 1
+            print("Number of Nodes:", num_nodes)
 
             # Create an adjacency matrix.
             adjacency_matrix = np.zeros((num_nodes, num_nodes))
@@ -5913,8 +6015,9 @@ class Graph:
         if rootVertex == None:
             rootVertex, root_index = vertex_max_degree(graph, vertices)
         else:
-            root_index = Vertex.Index(rootVertex, vertices)
-
+            root_index = Vertex.Index(rootVertex, vertices, tolerance=tolerance)
+        if root_index == None:
+            root_index = 0
         if 'rad' in layout.lower():
             positions = radial_layout(edges, root_index=root_index)
         elif 'spring' in layout.lower():
@@ -6248,7 +6351,8 @@ class Graph:
                  yKey: str = "y",
                  zKey: str = "z",
                  geometryKey: str = "brep",
-                 mantissa: int = 6):
+                 mantissa: int = 6,
+                 tolerance: float = 0.0001):
         """
         Converts the input graph into JSON data.
 
@@ -6280,6 +6384,8 @@ class Graph:
             The desired key name to use for geometry. The default is "brep".
         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
         -------
@@ -6329,22 +6435,23 @@ class Graph:
         for i, e in enumerate(edges):
             sv = Edge.StartVertex(e)
             ev = Edge.EndVertex(e)
-            svi = Vertex.Index(sv, vertices)
-            evi = Vertex.Index(ev, vertices)
-            sv_label = v_labels[svi]
-            ev_label = v_labels[evi]
-            d = Topology.Dictionary(e)
-            
-            d = Dictionary.SetValueAtKey(d, sourceKey, sv_label)
-            d = Dictionary.SetValueAtKey(d, targetKey, ev_label)
-            e_dict = Dictionary.PythonDictionary(d)
-            e_label = Dictionary.ValueAtKey(d, edgeLabelKey)
-            if isinstance(e_label, str):
+            svi = Vertex.Index(sv, vertices, tolerance=tolerance)
+            evi = Vertex.Index(ev, vertices, tolerance=tolerance)
+            if not svi == None and not evi == None:
+                sv_label = v_labels[svi]
+                ev_label = v_labels[evi]
+                d = Topology.Dictionary(e)
+                
+                d = Dictionary.SetValueAtKey(d, sourceKey, sv_label)
+                d = Dictionary.SetValueAtKey(d, targetKey, ev_label)
+                e_dict = Dictionary.PythonDictionary(d)
                 e_label = Dictionary.ValueAtKey(d, edgeLabelKey)
-            else:
-                e_label = "Edge_"+str(i).zfill(n)
-            e_labels.append(e_label)
-            e_dicts.append(e_dict)
+                if isinstance(e_label, str):
+                    e_label = Dictionary.ValueAtKey(d, edgeLabelKey)
+                else:
+                    e_label = "Edge_"+str(i).zfill(n)
+                e_labels.append(e_label)
+                e_dicts.append(e_dict)
         e_labels = Helper.MakeUnique(e_labels)
         for i, e_label in enumerate(e_labels):
             j_data[edgesKey][e_label] = e_dicts[i]
@@ -6405,7 +6512,7 @@ class Graph:
         return json_string
     
     @staticmethod
-    def LocalClusteringCoefficient(graph, vertices=None, mantissa=6):
+    def LocalClusteringCoefficient(graph, vertices: list = None, 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.
 
@@ -6414,9 +6521,11 @@ class Graph:
         graph : topologic_core.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 input list of vertices. If set to None, the local clustering coefficient of all vertices will be computed. The default is None.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
         
         Returns
         -------
@@ -6470,7 +6579,7 @@ class Graph:
         adjacency_matrix = Graph.AdjacencyMatrix(graph)
         lcc = []
         for v in vertices:
-            i = Vertex.Index(v, g_vertices)
+            i = Vertex.Index(v, g_vertices, tolerance=tolerance)
             if not i == None:
                 lcc.append(round(local_clustering_coefficient(adjacency_matrix, i), mantissa))
             else:
@@ -6556,9 +6665,10 @@ class Graph:
                 vertices = Topology.Vertices(path)
                 pathCost = 0
                 for vertex in vertices:
-                    index = Vertex.Index(vertex, g_vertices)
-                    d = Topology.Dictionary(g_vertices[index])
-                    value = Dictionary.ValueAtKey(d, vertexKey)
+                    index = Vertex.Index(vertex, g_vertices, tolerance=tolerance)
+                    if not index == None:
+                        d = Topology.Dictionary(g_vertices[index])
+                        value = Dictionary.ValueAtKey(d, vertexKey)
                     if not value == None:
                         pathCost += value
                 lengths[i] += pathCost
@@ -6697,29 +6807,31 @@ class Graph:
         edgeMatrix = Graph.AdjacencyMatrix(graph, edgeKeyFwd=edgeKeyFwd, edgeKeyBwd=edgeKeyBwd, bidirKey=bidirKey, bidirectional=bidirectional, useEdgeIndex = True, useEdgeLength=False, tolerance=tolerance)
         vertices = Graph.Vertices(graph)
         edges = Graph.Edges(graph)
-        sourceIndex = Vertex.Index(source, vertices)
-        sinkIndex = Vertex.Index(sink, vertices)
-        max_flow, am = ford_fulkerson(adjMatrix=adjMatrix, source=sourceIndex, sink=sinkIndex)
-        for i in range(len(am)):
-            row = am[i]
-            for j in range(len(row)):
-                residual = am[i][j]
-                edge = edges[edgeMatrix[i][j]-1]
-                d = Topology.Dictionary(edge)
-                if not d == None:
-                    keys = Dictionary.Keys(d)
-                    values = Dictionary.Values(d)
-                else:
-                    keys = []
-                    values = []
-                keys.append(residualKey)
-                values.append(residual)
-                d = Dictionary.ByKeysValues(keys, values)
-                edge = Topology.SetDictionary(edge, d)
+        sourceIndex = Vertex.Index(source, vertices, tolerance=tolerance)
+        sinkIndex = Vertex.Index(sink, vertices, tolerance=tolerance)
+        max_flow = None
+        if not sourceIndex == None and not sinkIndex == None:
+            max_flow, am = ford_fulkerson(adjMatrix=adjMatrix, source=sourceIndex, sink=sinkIndex)
+            for i in range(len(am)):
+                row = am[i]
+                for j in range(len(row)):
+                    residual = am[i][j]
+                    edge = edges[edgeMatrix[i][j]-1]
+                    d = Topology.Dictionary(edge)
+                    if not d == None:
+                        keys = Dictionary.Keys(d)
+                        values = Dictionary.Values(d)
+                    else:
+                        keys = []
+                        values = []
+                    keys.append(residualKey)
+                    values.append(residual)
+                    d = Dictionary.ByKeysValues(keys, values)
+                    edge = Topology.SetDictionary(edge, d)
         return max_flow
 
     @staticmethod
-    def MeshData(g):
+    def MeshData(g, tolerance: float = 0.0001):
         """
         Returns the mesh data of the input graph.
 
@@ -6727,6 +6839,8 @@ class Graph:
         ----------
         graph : topologic_core.Graph
             The input graph.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
 
         Returns
         -------
@@ -6755,11 +6869,12 @@ class Graph:
         for g_edge in g_edges:
             sv = g_edge.StartVertex()
             ev = g_edge.EndVertex()
-            si = Vertex.Index(sv, g_vertices)
-            ei = Vertex.Index(ev, g_vertices)
-            m_edges.append([si, ei])
-            d = Dictionary.PythonDictionary(Topology.Dictionary(g_edge))
-            e_dicts.append(d)
+            si = Vertex.Index(sv, g_vertices, tolerance=tolerance)
+            ei = Vertex.Index(ev, g_vertices, tolerance=tolerance)
+            if (not si == None) and (not ei == None):
+                m_edges.append([si, ei])
+                d = Dictionary.PythonDictionary(Topology.Dictionary(g_edge))
+                e_dicts.append(d)
         return {'vertices':m_vertices,
                 'edges': m_edges,
                 'vertexDictionaries': v_dicts,
@@ -7231,7 +7346,9 @@ class Graph:
                 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))
+                        vi = Vertex.Index(incoming_vertex, vertices, tolerance=tolerance)
+                        if not vi == None:
+                            incoming_score += scores[vi] / len(Graph.IncomingVertices(graph, incoming_vertex, directed=directed))
                 new_scores[i] = alpha * incoming_score + (1 - alpha) / num_vertices
 
             # Check for convergence
@@ -7286,9 +7403,14 @@ class Graph:
 
     
     @staticmethod
-    def PyvisGraph(graph, path, overwrite=True, height=900, backgroundColor="white", fontColor="black", notebook=False,
-                   vertexSize=6, vertexSizeKey=None, vertexColor="black", vertexColorKey=None, vertexLabelKey=None, vertexGroupKey=None, vertexGroups=None, minVertexGroup=None, maxVertexGroup=None, 
-                   edgeLabelKey=None, edgeWeight=0, edgeWeightKey=None, showNeighbours=True, selectMenu=True, filterMenu=True, colorScale="viridis"):
+    def PyvisGraph(graph, path, overwrite: bool = True, height: int = 900, backgroundColor: str = "white",
+                   fontColor: str = "black", notebook: bool = False,
+                   vertexSize: int = 6, vertexSizeKey: str = None, vertexColor: str = "black",
+                   vertexColorKey: str = None, vertexLabelKey: str = None, vertexGroupKey: str = None,
+                   vertexGroups: list = None, minVertexGroup: float = None, maxVertexGroup: float = None, 
+                   edgeLabelKey: str = None, edgeWeight: int = 0, edgeWeightKey: str = None,
+                   showNeighbours: bool = True, selectMenu: bool = True,
+                   filterMenu: bool = True, colorScale: str = "viridis", tolerance: float = 0.0001):
         """
         Displays a pyvis graph. See https://pyvis.readthedocs.io/.
 
@@ -7341,7 +7463,8 @@ class Graph:
             If set to True, a filtering menu will be displayed. The default is True.
         colorScale : str , optional
             The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
-
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
         Returns
         -------
         None
@@ -7367,7 +7490,7 @@ class Graph:
                 from pyvis.network import Network
                 print("Graph.PyvisGraph - Information: pyvis library installed correctly.")
             except:
-                warnings.warn("Graph - Error: Could not import pyvis. Please try to install pyvis manually. Retruning None.")
+                warnings.warn("Graph - Error: Could not import pyvis. Please try to install pyvis manually. Returning None.")
                 return None
         
         net = Network(height=str(height)+"px", width="100%", bgcolor=backgroundColor, font_color=fontColor, select_menu=selectMenu, filter_menu=filterMenu, cdn_resources="remote", notebook=notebook)
@@ -7443,9 +7566,10 @@ class Graph:
                     w = weightValue
             sv = Edge.StartVertex(e)
             ev = Edge.EndVertex(e)
-            svi = Vertex.Index(sv, vertices)
-            evi = Vertex.Index(ev, vertices)
-            net.add_edge(svi, evi, weight=w, label=edge_label)
+            svi = Vertex.Index(sv, vertices, tolerance=tolerance)
+            evi = Vertex.Index(ev, vertices, tolerance=tolerance)
+            if (not svi == None) and (not evi == None):
+                net.add_edge(svi, evi, weight=w, label=edge_label)
         net.inherit_edge_colors(False)
         
         # add neighbor data to node hover data and compute vertexSize

topologicpy/Neo4j.py

@@ -339,8 +339,8 @@ class Neo4j:
             e = edges[i]
             sv = e.StartVertex()
             ev = e.EndVertex()
-            sn = nodes[Vertex.Index(sv, vertices, tolerance)]
-            en = nodes[Vertex.Index(ev, vertices, tolerance)]
+            sn = nodes[Vertex.Index(sv, vertices, tolerance=tolerance)]
+            en = nodes[Vertex.Index(ev, vertices, tolerance=tolerance)]
             relationshipType = Dictionary.ValueAtKey(e, relationshipKey)
             if not (relationshipType):
                 relationshipType = "Connected To"