topologicpy 0.7.93__py3-none-any.whl → 0.7.96__py3-none-any.whl

topologicpy/Face.py

@@ -1124,6 +1124,123 @@ class Face():
         dirA = Face.Normal(face, outputType="xyz", mantissa=mantissa)
         return Vector.CompassAngle(vectorA=dirA, vectorB=north, mantissa=mantissa, tolerance=tolerance)
 
+    @staticmethod
+    def CShape(origin=None,
+            width=1,
+            length=1,
+            a=0.25,
+            b=0.25,
+            c=0.25,
+            flipHorizontal = False,
+            flipVertical = False,
+            direction=[0,0,1],
+            placement="center",
+            tolerance=0.0001,
+            silent=False):
+        """
+        Creates a C-shape.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the C-shape. The default is None which results in the C-shape being placed at (0, 0, 0).
+        width : float , optional
+            The overall width of the C-shape. The default is 1.0.
+        length : float , optional
+            The overall length of the C-shape. The default is 1.0.
+        a : float , optional
+            The hortizontal thickness of the vertical arm of the C-shape. The default is 0.25.
+        b : float , optional
+            The vertical thickness of the bottom horizontal arm of the C-shape. The default is 0.25.
+        c : float , optional
+            The vertical thickness of the top horizontal arm of the C-shape. The default is 0.25.
+        direction : list , optional
+            The vector representing the up direction of the C-shape. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the C-shape. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        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.Face
+            The created C-shape.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
+        if not isinstance(width, int) and not isinstance(width, float):
+            if not silent:
+                print("Face.CShape - Error: The width input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(length, int) and not isinstance(length, float):
+            if not silent:
+                print("Face.CShape - Error: The length input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(a, int) and not isinstance(a, float):
+            if not silent:
+                print("Face.CShape - Error: The a input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(b, int) and not isinstance(b, float):
+            if not silent:
+                print("Face.CShape - Error: The b input parameter is not a valid number. Returning None.")
+            return None
+        if width <= tolerance:
+            if not silent:
+                print("Face.CShape - Error: The width input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if length <= tolerance:
+            if not silent:
+                print("Face.CShape - Error: The length input parameter must be a positive number  greater than the tolerance input parameter. Returning None.")
+            return None
+        if a <= tolerance:
+            if not silent:
+                print("Face.CShape - Error: The a input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if b <= tolerance:
+            if not silent:
+                print("Face.CShape - Error: The b input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if a >= (width - tolerance):
+            if not silent:
+                print("Face.CShape - Error: The a input parameter must be less than the width input parameter. Returning None.")
+            return None
+        if b+c >= (length - tolerance):
+            if not silent:
+                print("Face.CShape - Error: The b and c input parameters must add to less than the length input parameter. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Face.CShape - Error: The origin input parameter is not a valid topologic vertex. Returning None.")
+            return None
+        if not isinstance(direction, list):
+            if not silent:
+                print("Face.CShape - Error: The direction input parameter is not a valid list. Returning None.")
+            return None
+        if not len(direction) == 3:
+            if not silent:
+                print("Face.CShape - Error: The direction input parameter is not a valid vector. Returning None.")
+            return None
+        c_shape_wire = Wire.CShape(origin=origin,
+                                   width=width,
+                                   length=length,
+                                   a=a,
+                                   b=b,
+                                   c=c,
+                                   flipHorizontal=flipHorizontal,
+                                   flipVertical=flipVertical,
+                                   direction=direction,
+                                   placement=placement,
+                                   tolerance=tolerance,
+                                   silent=silent)
+        return Face.ByWire(c_shape_wire, tolerance=tolerance, silent=silent)
+
     @staticmethod
     def Edges(face) -> list:
         """
@@ -1685,6 +1802,123 @@ class Face():
         plane_b = normalize_plane_coefficients(plane_b)
         return are_planes_coplanar(plane_a, plane_b, tolerance=tolerance)
 
+    @staticmethod
+    def IShape(origin=None,
+            width=1,
+            length=1,
+            a=0.25,
+            b=0.25,
+            c=0.25,
+            flipHorizontal = False,
+            flipVertical = False,
+            direction=[0,0,1],
+            placement="center",
+            tolerance=0.0001,
+            silent=False):
+        """
+        Creates an I-shape.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the I-shape. The default is None which results in the I-shape being placed at (0, 0, 0).
+        width : float , optional
+            The overall width of the I-shape. The default is 1.0.
+        length : float , optional
+            The overall length of the I-shape. The default is 1.0.
+        a : float , optional
+            The hortizontal thickness of the central vertical arm of the I-shape. The default is 0.25.
+        b : float , optional
+            The vertical thickness of the bottom horizontal arm of the I-shape. The default is 0.25.
+        c : float , optional
+            The vertical thickness of the top horizontal arm of the I-shape. The default is 0.25.
+        direction : list , optional
+            The vector representing the up direction of the I-shape. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the I-shape. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        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.Face
+            The created I-shape.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
+        if not isinstance(width, int) and not isinstance(width, float):
+            if not silent:
+                print("Face.IShape - Error: The width input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(length, int) and not isinstance(length, float):
+            if not silent:
+                print("Face.IShape - Error: The length input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(a, int) and not isinstance(a, float):
+            if not silent:
+                print("Face.IShape - Error: The a input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(b, int) and not isinstance(b, float):
+            if not silent:
+                print("Face.IShape - Error: The b input parameter is not a valid number. Returning None.")
+            return None
+        if width <= tolerance:
+            if not silent:
+                print("Face.IShape - Error: The width input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if length <= tolerance:
+            if not silent:
+                print("Face.IShape - Error: The length input parameter must be a positive number  greater than the tolerance input parameter. Returning None.")
+            return None
+        if a <= tolerance:
+            if not silent:
+                print("Face.IShape - Error: The a input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if b <= tolerance:
+            if not silent:
+                print("Face.IShape - Error: The b input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if a >= (width - tolerance):
+            if not silent:
+                print("Face.IShape - Error: The a input parameter must be less than the width input parameter. Returning None.")
+            return None
+        if b+c >= (length - tolerance):
+            if not silent:
+                print("Face.IShape - Error: The b and c input parameters must add to less than the length input parameter. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Face.IShape - Error: The origin input parameter is not a valid topologic vertex. Returning None.")
+            return None
+        if not isinstance(direction, list):
+            if not silent:
+                print("Face.IShape - Error: The direction input parameter is not a valid list. Returning None.")
+            return None
+        if not len(direction) == 3:
+            if not silent:
+                print("Face.IShape - Error: The direction input parameter is not a valid vector. Returning None.")
+            return None
+        i_shape_wire = Wire.IShape(origin=origin,
+                                   width=width,
+                                   length=length,
+                                   a=a,
+                                   b=b,
+                                   c=c,
+                                   flipHorizontal=flipHorizontal,
+                                   flipVertical=flipVertical,
+                                   direction=direction,
+                                   placement=placement,
+                                   tolerance=tolerance,
+                                   silent=silent)
+        return Face.ByWire(i_shape_wire, tolerance=tolerance, silent=silent)
+
     @staticmethod
     def Isovist(face, vertex, obstacles: list = [], direction: list = [0,1,0], fov: float = 360, transferDictionaries: bool = False, metrics: bool = False, triangles: bool = False, mantissa: int = 6, tolerance: float = 0.0001):
         """
@@ -2294,6 +2528,120 @@ class Face():
                 return_face = Topology.AddContent(return_face, triangle_list)
         return return_face
 
+
+    @staticmethod
+    def LShape(origin=None,
+            width=1,
+            length=1,
+            a=0.25,
+            b=0.25,
+            flipHorizontal = False,
+            flipVertical = False,
+            direction=[0,0,1],
+            placement="center",
+            tolerance=0.0001,
+            silent=False):
+        """
+        Creates an L-shape.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the L-shape. The default is None which results in the L-shape being placed at (0, 0, 0).
+        width : float , optional
+            The overall width of the L-shape. The default is 1.0.
+        length : float , optional
+            The overall length of the L-shape. The default is 1.0.
+        a : float , optional
+            The hortizontal thickness of the vertical arm of the L-shape. The default is 0.25.
+        b : float , optional
+            The vertical thickness of the horizontal arm of the L-shape. The default is 0.25.
+        direction : list , optional
+            The vector representing the up direction of the L-shape. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the L-shape. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        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.Face
+            The created L-shape.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
+        if not isinstance(width, int) and not isinstance(width, float):
+            if not silent:
+                print("Face.LShape - Error: The width input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(length, int) and not isinstance(length, float):
+            if not silent:
+                print("Face.LShape - Error: The length input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(a, int) and not isinstance(a, float):
+            if not silent:
+                print("Face.LShape - Error: The a input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(b, int) and not isinstance(b, float):
+            if not silent:
+                print("Face.LShape - Error: The b input parameter is not a valid number. Returning None.")
+            return None
+        if width <= tolerance:
+            if not silent:
+                print("Face.LShape - Error: The width input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if length <= tolerance:
+            if not silent:
+                print("Face.LShape - Error: The length input parameter must be a positive number  greater than the tolerance input parameter. Returning None.")
+            return None
+        if a <= tolerance:
+            if not silent:
+                print("Face.LShape - Error: The a input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if b <= tolerance:
+            if not silent:
+                print("Face.LShape - Error: The b input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if a >= (width - tolerance):
+            if not silent:
+                print("Face.LShape - Error: The a input parameter must be less than the width input parameter. Returning None.")
+            return None
+        if b >= (length - tolerance):
+            if not silent:
+                print("Face.LShape - Error: The b input parameter must be less than the length input parameter. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Face.LShape - Error: The origin input parameter is not a valid topologic vertex. Returning None.")
+            return None
+        if not isinstance(direction, list):
+            if not silent:
+                print("Face.LShape - Error: The direction input parameter is not a valid list. Returning None.")
+            return None
+        if not len(direction) == 3:
+            if not silent:
+                print("Face.LShape - Error: The direction input parameter is not a valid vector. Returning None.")
+            return None
+        l_shape_wire = Wire.LShape(origin=origin,
+                                   width=width,
+                                   length=length,
+                                   a=a,
+                                   b=b,
+                                   flipHorizontal=flipHorizontal,
+                                   flipVertical=flipVertical,
+                                   direction=direction,
+                                   placement=placement,
+                                   tolerance=tolerance,
+                                   silent=silent)
+        return Face.ByWire(l_shape_wire, tolerance=tolerance, silent=silent)
+
     @staticmethod
     def MedialAxis(face, resolution: int = 0, externalVertices: bool = False, internalVertices: bool = False, toLeavesOnly: bool = False, angTolerance: float = 0.1, tolerance: float = 0.0001):
         """
@@ -3193,6 +3541,119 @@ class Face():
             trimmed_face = face.Difference(trimmed_face)
         return trimmed_face
     
+    @staticmethod
+    def TShape(origin=None,
+            width=1,
+            length=1,
+            a=0.5,
+            b=0.5,
+            flipHorizontal = False,
+            flipVertical = False,
+            direction=[0,0,1],
+            placement="center",
+            tolerance=0.0001,
+            silent=False):
+        """
+        Creates a T-shape.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The location of the origin of the T-shape. The default is None which results in the T-shape being placed at (0, 0, 0).
+        width : float , optional
+            The overall width of the T-shape. The default is 1.0.
+        length : float , optional
+            The overall length of the T-shape. The default is 1.0.
+        a : float , optional
+            The hortizontal thickness of the vertical arm of the T-shape. The default is 0.5.
+        b : float , optional
+            The vertical thickness of the horizontal arm of the T-shape. The default is 0.5.
+        direction : list , optional
+            The vector representing the up direction of the T-shape. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the T-shape. This can be "center", "lowerleft", "upperleft", "lowerright", "upperright". It is case insensitive. The default is "center".
+        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.Face
+            The created T-shape.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Topology import Topology
+
+        if not isinstance(width, int) and not isinstance(width, float):
+            if not silent:
+                print("Face.TShape - Error: The width input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(length, int) and not isinstance(length, float):
+            if not silent:
+                print("Face.TShape - Error: The length input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(a, int) and not isinstance(a, float):
+            if not silent:
+                print("Face.TShape - Error: The a input parameter is not a valid number. Returning None.")
+            return None
+        if not isinstance(b, int) and not isinstance(b, float):
+            if not silent:
+                print("Face.LShape - Error: The b input parameter is not a valid number. Returning None.")
+            return None
+        if width <= tolerance:
+            if not silent:
+                print("Face.TShape - Error: The width input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if length <= tolerance:
+            if not silent:
+                print("Face.TShape - Error: The length input parameter must be a positive number  greater than the tolerance input parameter. Returning None.")
+            return None
+        if a <= tolerance:
+            if not silent:
+                print("Face.TShape - Error: The a input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if b <= tolerance:
+            if not silent:
+                print("Face.TShape - Error: The b input parameter must be a positive number greater than the tolerance input parameter. Returning None.")
+            return None
+        if a >= (width - tolerance):
+            if not silent:
+                print("Face.TShape - Error: The a input parameter must be less than the width input parameter. Returning None.")
+            return None
+        if b >= (length - tolerance):
+            if not silent:
+                print("Face.TShape - Error: The b input parameter must be less than the length input parameter. Returning None.")
+            return None
+        if origin == None:
+            origin = Vertex.Origin()
+        if not Topology.IsInstance(origin, "vertex"):
+            if not silent:
+                print("Face.TShape - Error: The origin input parameter is not a valid topologic vertex. Returning None.")
+            return None
+        if not isinstance(direction, list):
+            if not silent:
+                print("Face.TShape - Error: The direction input parameter is not a valid list. Returning None.")
+            return None
+        if not len(direction) == 3:
+            if not silent:
+                print("Face.TShape - Error: The direction input parameter is not a valid vector. Returning None.")
+            return None
+        t_shape_wire = Wire.TShape(origin=origin,
+                                   width=width,
+                                   length=length,
+                                   a=a,
+                                   b=b,
+                                   flipHorizontal=flipHorizontal,
+                                   flipVertical=flipVertical,
+                                   direction=direction,
+                                   placement=placement,
+                                   tolerance=tolerance,
+                                   silent=silent)
+        return Face.ByWire(t_shape_wire, tolerance=tolerance, silent=silent)
+
     @staticmethod
     def VertexByParameters(face, u: float = 0.5, v: float = 0.5):
         """

topologicpy/Graph.py

@@ -751,7 +751,7 @@ class Graph:
         return paths
 
     @staticmethod
-    def AreIsomorphic(graphA, graphB, maxIterations=10, silent=False):
+    def IsIsomorphic(graphA, graphB, maxIterations=10, silent=False):
         """
         Tests if the two input graphs are isomorphic according to the Weisfeiler Lehman graph isomorphism test. See https://en.wikipedia.org/wiki/Weisfeiler_Leman_graph_isomorphism_test
         
@@ -827,19 +827,19 @@ class Graph:
         
         if not Topology.IsInstance(graphA, "Graph") and not Topology.IsInstance(graphB, "Graph"):
             if not silent:
-                print("Graph.AreIsomorphic - Error: The input graph parameters are not valid graphs. Returning None.")
+                print("Graph.IsIsomorphic - Error: The input graph parameters are not valid graphs. Returning None.")
             return None
         if not Topology.IsInstance(graphA, "Graph"):
             if not silent:
-                print("Graph.AreIsomorphic - Error: The input graphA parameter is not a valid graph. Returning None.")
+                print("Graph.IsIsomorphic - Error: The input graphA parameter is not a valid graph. Returning None.")
             return None
         if not Topology.IsInstance(graphB, "Graph"):
             if not silent:
-                print("Graph.AreIsomorphic - Error: The input graphB parameter is not a valid graph. Returning None.")
+                print("Graph.IsIsomorphic - Error: The input graphB parameter is not a valid graph. Returning None.")
             return None
         if maxIterations <= 0:
             if not silent:
-                print("Graph.AreIsomorphic - Error: The input maxIterations parameter is not within a valid range. Returning None.")
+                print("Graph.IsIsomorphic - Error: The input maxIterations parameter is not within a valid range. Returning None.")
             return None
         
         g1 = Graph.AdjacencyDictionary(graphA)
@@ -4517,37 +4517,39 @@ class Graph:
         import warnings
         
         try:
-            import community as community_louvain
+            import igraph as ig
         except:
-            print("Graph.Community - Installing required pyhon-louvain library.")
+            print("Graph.Community - Installing required pyhon-igraph library.")
             try:
-                os.system("pip install python-louvain")
+                os.system("pip install python-igraph")
             except:
-                os.system("pip install python-louvain --user")
+                os.system("pip install python-igraph --user")
             try:
-                import community as community_louvain
-                print("Graph.Community - python-louvain library installed correctly.")
+                import igraph as ig
+                print("Graph.Community - python-igraph library installed correctly.")
             except:
-                warnings.warn("Graph.Community - Error: Could not import python-louvain. Please install manually.")
+                warnings.warn("Graph.Community - Error: Could not import python-igraph. Please install manually.")
         
         if not Topology.IsInstance(graph, "graph"):
             if not silent:
                 print("Graph.Community - Error: The input graph parameter is not a valid topologic graph. Returning None")
             return None
         
+        mesh_data = Graph.MeshData(graph)
+        # Create an igraph graph from the edge list
+        ig_graph = ig.Graph(edges=mesh_data['edges'])
+
+        # Detect communities using Louvain method
+        communities = ig_graph.community_multilevel()
+
+        # Get the list of communities sorted same as vertices
+        community_list = communities.membership
         vertices = Graph.Vertices(graph)
-        nx_graph = Graph.NetworkXGraph(graph, mantissa=mantissa, tolerance=tolerance)
-        # Apply the Louvain algorithm
-        partition = community_louvain.best_partition(nx_graph)
-        communities = []
-        # Add the partition value to each node's properties
-        for node, community_id in partition.items():
-            nx_graph.nodes[node][key] = community_id
-            d = Topology.Dictionary(vertices[node])
-            d = Dictionary.SetValueAtKey(d, key, community_id)
-            vertices[node] = Topology.SetDictionary(vertices[node], d)
-            communities.append(community_id)
-        return communities
+        for i, v in enumerate(vertices):
+            d = Topology.Dictionary(v)
+            d = Dictionary.SetValueAtKey(d, key, community_list[i])
+            v = Topology.SetDictionary(v, d)
+        return community_list
 
     @staticmethod
     def Connect(graph, verticesA, verticesB, tolerance=0.0001):
@@ -8102,6 +8104,7 @@ class Graph:
 
         """
         from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Topology import Topology
 
@@ -8116,8 +8119,8 @@ class Graph:
         m_edges = []
         e_dicts = []
         for g_edge in g_edges:
-            sv = g_edge.StartVertex()
-            ev = g_edge.EndVertex()
+            sv = Edge.StartVertex(g_edge)
+            ev = Edge.EndVertex(g_edge)
             si = Vertex.Index(sv, g_vertices, tolerance=tolerance)
             ei = Vertex.Index(ev, g_vertices, tolerance=tolerance)
             if (not si == None) and (not ei == None):

topologicpy/Honeybee.py

@@ -255,7 +255,7 @@ class Honeybee:
 
         def cellFloor(cell):
             faces = Topology.Faces(cell)
-            c = [x.CenterOfMass().Z() for x in faces]
+            c = [Vertex.Z(Topology.CenterOfMass(x)) for x in faces]
             return round(min(c),2)
 
         def floorLevels(cells, min_difference):

topologicpy/Neo4j.py

@@ -413,6 +413,7 @@ class Neo4j:
 
         """
         from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
         from topologicpy.Graph import Graph
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
@@ -458,8 +459,8 @@ class Neo4j:
             nodes.append(n)
         for i in range(len(edges)):
             e = edges[i]
-            sv = e.StartVertex()
-            ev = e.EndVertex()
+            sv = Edge.StartVertex(e)
+            ev = Edge.EndVertex(e)
             sn = nodes[Vertex.Index(vertex=sv, vertices=vertices, strict=False, tolerance=tolerance)]
             en = nodes[Vertex.Index(vertex=ev, vertices=vertices, strict=False, tolerance=tolerance)]
             ed = Topology.Dictionary(e)