topologicpy 0.7.72__py3-none-any.whl → 0.7.74__py3-none-any.whl

topologicpy/CellComplex.py

@@ -1006,6 +1006,64 @@ class CellComplex():
         shells = Topology.Shells(cellComplex)
         return shells
 
+    @staticmethod
+    def Torus(origin= None, majorRadius: float = 0.5, minorRadius: float = 0.125, uSides: int = 16, vSides: int = 8, direction: list = [0, 0, 1], placement: str = "center", tolerance: float = 0.0001):
+        """
+        Creates a torus.
+
+        Parameters
+        ----------
+        origin : topologic_core.Vertex , optional
+            The origin location of the torus. The default is None which results in the torus being placed at (0, 0, 0).
+        majorRadius : float , optional
+            The major radius of the torus. The default is 0.5.
+        minorRadius : float , optional
+            The minor radius of the torus. The default is 0.1.
+        uSides : int , optional
+            The number of sides along the longitude of the torus. The default is 16.
+        vSides : int , optional
+            The number of sides along the latitude of the torus. The default is 8.
+        direction : list , optional
+            The vector representing the up direction of the torus. The default is [0, 0, 1].
+        placement : str , optional
+            The description of the placement of the origin of the torus. This can be "bottom", "center", or "lowerleft". It is case insensitive. The default is "center".
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Cell
+            The created torus.
+
+        """
+        
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
+        from topologicpy.Topology import Topology
+        
+        if not Topology.IsInstance(origin, "Vertex"):
+            origin = Vertex.ByCoordinates(0, 0, 0)
+        if not Topology.IsInstance(origin, "Vertex"):
+            print("Cell.Torus - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
+            return None
+        c = Wire.Circle(origin=Vertex.Origin(), radius=minorRadius, sides=vSides, fromAngle=0, toAngle=360, close=False, direction=[0, 1, 0], placement="center")
+        c = Face.ByWire(c)
+        c = Topology.Translate(c, abs(majorRadius-minorRadius), 0, 0)
+        torus = Topology.Spin(c, origin=Vertex.Origin(), triangulate=False, direction=[0, 0, 1], angle=360, sides=uSides, tolerance=tolerance)
+        if Topology.Type(torus) == Topology.TypeID("Shell"):
+            faces = Topology.Faces(torus)
+            torus = CellComplex.ByFaces(faces)
+        if placement.lower() == "bottom":
+            torus = Topology.Translate(torus, 0, 0, minorRadius)
+        elif placement.lower() == "lowerleft":
+            torus = Topology.Translate(torus, majorRadius, majorRadius, minorRadius)
+
+        torus = Topology.Orient(torus, origin=Vertex.Origin(), dirA=[0, 0, 1], dirB=direction)
+        torus = Topology.Place(torus, originA=Vertex.Origin(), originB=origin)
+        return torus
+
     @staticmethod
     def Vertices(cellComplex) -> list:
         """

topologicpy/Graph.py

@@ -742,6 +742,102 @@ class Graph:
         _ = graph.AllPaths(vertexA, vertexB, True, timeLimit, paths) # Hook to Core
         return paths
 
+    @staticmethod
+    def AreIsomorphic(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
+        
+        Parameters
+        ----------
+        graphA : topologic_core.Graph
+            The first input graph.
+        graphB : topologic_core.Graph
+            The second input graph.
+        maxIterations : int , optional
+            This number limits the number of iterations to prevent the function from running indefinitely, particularly for very large or complex graphs.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+        
+        Returns
+        -------
+        bool
+            True if the two input graphs are isomorphic. False otherwise
+
+        """
+
+        from topologicpy.Topology import Topology
+
+        def weisfeiler_lehman_test(graph1, graph2, max_iterations=10):
+            """
+            Test if two graphs are isomorphic using the Weisfeiler-Leman (WL) algorithm with early stopping.
+
+            Parameters:
+            graph1 (dict): Adjacency list representation of the first graph.
+            graph2 (dict): Adjacency list representation of the second graph.
+            max_iterations (int): Maximum WL iterations allowed (default is 10).
+
+            Returns:
+            bool: True if the graphs are WL-isomorphic, False otherwise.
+            """
+
+            def wl_iteration(labels, graph):
+                """Perform one WL iteration and return updated labels."""
+                new_labels = {}
+                for node in graph:
+                    neighborhood_labels = sorted([labels[neighbor] for neighbor in graph[node]])
+                    new_labels[node] = (labels[node], tuple(neighborhood_labels))
+                unique_labels = {}
+                count = 0
+                for node in sorted(new_labels):
+                    if new_labels[node] not in unique_labels:
+                        unique_labels[new_labels[node]] = count
+                        count += 1
+                    new_labels[node] = unique_labels[new_labels[node]]
+                return new_labels
+
+            # Initialize labels
+            labels1 = {node: 1 for node in graph1}
+            labels2 = {node: 1 for node in graph2}
+
+            for i in range(max_iterations):
+                # Perform WL iteration for both graphs
+                new_labels1 = wl_iteration(labels1, graph1)
+                new_labels2 = wl_iteration(labels2, graph2)
+
+                # Check if the label distributions match
+                if sorted(new_labels1.values()) != sorted(new_labels2.values()):
+                    return False
+
+                # Check for stability (early stopping)
+                if new_labels1 == labels1 and new_labels2 == labels2:
+                    break
+
+                # Update labels for next iteration
+                labels1, labels2 = new_labels1, new_labels2
+
+            return True
+        
+        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.")
+            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.")
+            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.")
+            return None
+        if maxIterations <= 0:
+            if not silent:
+                print("Graph.AreIsomorphic - Error: The input maxIterations parameter is not within a valid range. Returning None.")
+            return None
+        
+        g1 = Graph.AdjacencyDictionary(graphA)
+        g2 = Graph.AdjacencyDictionary(graphB)
+        return weisfeiler_lehman_test(g1, g2, max_iterations=maxIterations)
+
     @staticmethod
     def AverageClusteringCoefficient(graph, mantissa: int = 6, silent: bool = False):
         """
@@ -1277,6 +1373,7 @@ class Graph:
             print("Graph.BetweenessCentrality - 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:
@@ -1298,7 +1395,15 @@ class Graph:
         if len(destinations) < 1:
             print("Graph.BetweenessCentrality - Error: The input list of destinations does not contain valid vertices. Returning None.")
             return None
-        
+        graphEdges = Graph.Edges(graph)
+        if len(graphEdges) == 0:
+            print("Graph.BetweenessCentrality - Warning: The input graph is a null graph.")
+            scores = [0 for t in vertices]
+            for i, v in enumerate(vertices):
+                d = Topology.Dictionary(v)
+                d = Dictionary.SetValueAtKey(d, key, scores[i])
+                v = Topology.SetDictionary(v, d)
+            return scores
         paths = []
         try:
             for so in tqdm(sources, desc="Computing Shortest Paths", leave=False):
@@ -1906,8 +2011,6 @@ class Graph:
         for i, vertices, in enumerate(vertices_ds):
             edges = edges_ds[i]
             g = Graph.ByVerticesEdges(vertices, edges)
-            temp_v = Graph.Vertices(g)
-            temp_e = Graph.Edges(g)
             if Topology.IsInstance(g, "Graph"):
                 if len(graphFeaturesKeys) == 0:
                     values = [graph_ids[i], graph_labels[i], graph_features[i]]
@@ -5526,19 +5629,35 @@ class Graph:
         return False
     
     @staticmethod
-    def Flatten(graph, layout="spring", k=0.8, seed=None, iterations=50, rootVertex=None, radius=0.5, tolerance=0.0001):
-        """
-        Flattens the input graph.
+    def Reshape(graph,
+                shape="spring_2d",
+                k=0.8, seed=None,
+                iterations=50,
+                rootVertex=None,
+                size=1,
+                sides=16,
+                key="",
+                tolerance=0.0001,
+                silent=False):
+        """
+        Reshapes the input graph according to the desired input shape parameter.
 
         Parameters
         ----------
         graph : topologic_core.Graph
             The input graph.
-        layout : str , optional
-            The desired mode for flattening. If set to 'spring', the algorithm uses a simplified version of the Fruchterman-Reingold force-directed algorithm to flatten and distribute the vertices.
-            If set to 'radial', the nodes will be distributed along concentric circles.
-            If set to 'tree', the nodes will be distributed using the Reingold-Tillford layout.
-            If set to 'circle', the nodes will be distributed on the cirumference of a circle. The default is 'spring'.
+        shape : str , optional
+            The desired shape of the graph.
+            If set to 'spring_2d' or 'spring_3d', the algorithm uses a simplified version of the Fruchterman-Reingold force-directed algorithm to distribute the vertices.
+            If set to 'radial_2d', the nodes will be distributed along concentric circles in the XY plane.
+            If set to 'tree_2d' or 'tree_3d', the nodes will be distributed using the Reingold-Tillford layout.
+            If set to 'circle_2d', the nodes will be distributed on the cirumference of a segemented circles  in the XY plane, based on the size and sides input parameter (radius=size/2).
+            If set to 'line_2d', the nodes will be distributed on a line in the XY plane based on the size input parameter (length=size).
+            If set to 'spehere_3d', the nodes will be distributed on the surface of a sphere based on the size input parameter raidus=size/2).
+            If set to 'grid_2d', the nodes will be distributed on a grid in the XY plane with size based on the size input parameter (length=width=size).
+            If set to 'grid_3d', the nodes will be distributed on a 3D cubic grid/matrix based on the size input parameter(width=length=height=size).
+            If set to 'cluster_2d', or 'cluster_3d, the nodes will be clustered according to the 'key' input parameter. The overall radius of the cluster is determined by the size input parameter (radius = size/2)
+            The default is 'spring_2d'.
         k : float, optional
             The desired spring constant to use for the attractive and repulsive forces. The default is 0.8.
         seed : int , optional
@@ -5547,20 +5666,38 @@ 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.
-        radius : float, optional
-            The desired radius for the circle layout option. The default is 0.5.
+        sides : int , optional
+            The desired number of sides of the circle layout option. The default is 16
+        length : float, optional
+            The desired horizontal length for the line layout option. The default is 1.0.
+        key : string, optional
+            The key under which to find the clustering value for the 'cluster_2d' and 'cluster_3d' options. The default is "".
         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.Graph
-            The flattened graph.
+            The reshaped graph.
 
         """
         from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Wire import Wire
+        from topologicpy.Face import Face
+        from topologicpy.Graph import Graph
+        from topologicpy.Grid import Grid
+        from topologicpy.Helper import Helper
+        from topologicpy.Vector import Vector
         from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
         import numpy as np
+        import math
+        from collections import defaultdict
+        import random
+
 
         def buchheim(tree):
             dt = firstwalk(_DrawTree(tree))
@@ -5674,7 +5811,7 @@ class Graph:
             Returns:
                 A numpy array representing the adjacency matrix.
             """
-            from topologicpy.Helper import Helper
+            
             # Get the number of nodes from the edge list.
             flat_list = Helper.Flatten(edge_list)
             flat_list = [x for x in flat_list if not x == None]
@@ -5714,15 +5851,226 @@ class Graph:
                     new_roots.extend(children)
                 old_roots = new_roots
             return root, num_nodes
+        
+        def generate_cubic_matrix(size, min_points):
+            # Calculate the minimum points per axis to reach or exceed min_points in total
+            points_per_axis = int(np.ceil(min_points ** (1/3)))
+            
+            # Calculate the spacing based on the size and points per axis
+            spacing = size / (points_per_axis - 1) if points_per_axis > 1 else 0
+            
+            # Generate linearly spaced points from -size/2 to size/2 along each axis
+            x = np.linspace(-size / 2, size / 2, points_per_axis)
+            y = np.linspace(-size / 2, size / 2, points_per_axis)
+            z = np.linspace(-size / 2, size / 2, points_per_axis)
+            
+            # Create a meshgrid and stack them to get XYZ coordinates for each point
+            X, Y, Z = np.meshgrid(x, y, z)
+            points = np.vstack([X.ravel(), Y.ravel(), Z.ravel()]).T
+            return points
+        
+        def vertex_max_degree(graph, vertices):
+            degrees = [Graph.VertexDegree(graph, vertex) for vertex in vertices]
+            i = degrees.index(max(degrees))
+            return vertices[i], i
+        
+        def circle_layout_2d(graph, radius=0.5, sides=16):
+            vertices = Graph.Vertices(graph)
+            edges = Graph.Edges(graph)
+            edge_dict = {}
 
+            for i, edge in enumerate(edges):
+                sv = Edge.StartVertex(edge)
+                ev = Edge.EndVertex(edge)
+                si = Vertex.Index(sv, vertices)
+                ei = Vertex.Index(ev, vertices)
+                edge_dict[str(si)+"_"+str(ei)] = i
+                edge_dict[str(ei)+"_"+str(si)] = i
+            n = len(vertices)
+            c = Wire.Circle(radius=radius, sides=sides)
+            c_vertices = []
+            for i in range(n):
+                u = i*(1/n)
+                c_vertices.append(Wire.VertexByParameter(c, u))
 
-        def circle_layout(graph, radius=0.5):
-            from topologicpy.Vertex import Vertex
-            from topologicpy.Vector import Vector
-            from topologicpy.Wire import Wire
-            from topologicpy.Graph import Graph
-            from topologicpy.Edge import Edge
+            for i, c_v in enumerate(c_vertices):
+                d = Topology.Dictionary(vertices[i])
+                c_v = Topology.SetDictionary(c_v, d)
+            adj_dict = Graph.AdjacencyDictionary(graph)
+            keys = adj_dict.keys()
+            
+            c_edges = []
+            used = [[0] * n for _ in range(n)]
+            for key in keys:
+                x = int(key)
+                adj_vertices = [int(v) for v in adj_dict[key]]
+                for y in adj_vertices:
+                    if used[x][y] == 0:
+                        v1 = Vector.ByCoordinates(Vertex.X(c_vertices[x]), Vertex.Y(c_vertices[x]), Vertex.Z(c_vertices[x]))
+                        v2 = Vector.ByCoordinates(Vertex.X(c_vertices[y]), Vertex.Y(c_vertices[y]), Vertex.Z(c_vertices[y]))
+                        ang1 = Vector.CompassAngle(v1, [0,1,0])
+                        ang2 = Vector.CompassAngle(v2, [0,1,0])
+                        if ang2-ang1 < 180:
+                            e = Edge.ByVertices(c_vertices[x], c_vertices[y])
+                        else:
+                            e = Edge.ByVertices(c_vertices[y], c_vertices[x])
+                        orig_edge_index = edge_dict.get(str(x)+"_"+str(y), edge_dict.get(str(y)+"_"+str(x), None))
+                        if orig_edge_index:
+                            d = Topology.Dictionary(edges[orig_edge_index])
+                            e = Topology.SetDictionary(e, d)
+                            c_edges.append(e)
+                            used[x][y] = 1
+                            used[y][x] = 1
+            new_g = Graph.ByVerticesEdges(c_vertices, c_edges)
+            return new_g
+        
+        def cluster_layout_2d(graph, key, radius=0.5):
+            
+            d = Graph.MeshData(graph)
+            edges = d['edges']
+            v_dicts = d['vertexDictionaries']
+            e_dicts = d['edgeDictionaries']
+            vertices = Graph.Vertices(graph)
+            # Step 1: Group objects by key value while remembering their original indices
+            grouped_objects = defaultdict(list)
+            object_indices = []  # Stores original indices of objects in the order they were grouped
+
+            for idx, obj in enumerate(vertices):
+                d = Topology.Dictionary(obj)
+                value = Dictionary.ValueAtKey(d, key)
+                grouped_objects[value].append((obj, idx))
+                object_indices.append((value, idx))
+
+            # Step 2: Compute cluster centers on the circumference of a circle
+            cluster_centers = {}
+            num_clusters = len(grouped_objects)
+            
+            # Function to generate cluster center on the circle's circumference
+            def generate_cluster_center(index, total_clusters, circle_radius):
+                # Distribute cluster centers evenly along the circumference of a circle
+                angle = (2 * math.pi * index) / total_clusters  # Equal angle separation
+                x = circle_radius * math.cos(angle)
+                y = circle_radius * math.sin(angle)
+                return (x, y)
+
+            # Step 3: Compute vertices for each cluster
+            object_positions = [None] * len(vertices)  # Placeholder list for ordered vertices
+            cluster_index = 0
+
+            for value, objs in grouped_objects.items():
+                intra_cluster_radius = radius*(len(objs)/len(vertices) + 0.1)
+                # Determine the center of the current cluster
+                if value not in cluster_centers:
+                    cluster_center = generate_cluster_center(cluster_index, num_clusters, radius)
+                    cluster_centers[value] = cluster_center
+                    cluster_index += 1
+                else:
+                    cluster_center = cluster_centers[value]
+                
+                # Step 4: Place objects randomly around the cluster center
+                for obj, original_index in objs:
+                    # Randomly place the object within the intra-cluster circle
+                    r = intra_cluster_radius * math.sqrt(random.random())  # Random distance with sqrt for uniform distribution
+                    angle = random.uniform(0, 2 * math.pi)  # Random angle
+
+                    # Polar coordinates to Cartesian for local positioning
+                    x = cluster_center[0] + r * math.cos(angle)
+                    y = cluster_center[1] + r * math.sin(angle)
+
+                    # Save the coordinates in the correct order
+                    object_positions[original_index] = [x, y]
+            
+            positions = [[p[0], p[1], 0] for p in object_positions]
+            new_g = Graph.ByMeshData(positions, edges, v_dicts, e_dicts, tolerance=0.001)
+            return new_g
+
+        def cluster_layout_3d(graph, key, radius=0.5):
+            d = Graph.MeshData(graph)
+            edges = d['edges']
+            v_dicts = d['vertexDictionaries']
+            e_dicts = d['edgeDictionaries']
+            vertices = Graph.Vertices(graph)
+
+            # Step 1: Group objects by key value while remembering their original indices
+            grouped_objects = defaultdict(list)
+            object_indices = []  # Stores original indices of objects in the order they were grouped
+
+            for idx, obj in enumerate(vertices):
+                d = Topology.Dictionary(obj)
+                value = Dictionary.ValueAtKey(d, key)
+                grouped_objects[value].append((obj, idx))
+                object_indices.append((value, idx))
+
+            # Step 2: Compute cluster centers on the surface of a sphere
+            cluster_centers = {}
+            num_clusters = len(grouped_objects)
+            
+            # Function to generate cluster center on the surface of a sphere
+            def generate_cluster_center(index, total_clusters, sphere_radius):
+                # Use a spiral algorithm to distribute cluster centers evenly on a sphere's surface
+                phi = math.acos(1 - 2 * (index + 0.5) / total_clusters)  # Inclination angle
+                theta = math.pi * (1 + 5**0.5) * index  # Azimuthal angle (Golden angle)
+                
+                x = sphere_radius * math.sin(phi) * math.cos(theta)
+                y = sphere_radius * math.sin(phi) * math.sin(theta)
+                z = sphere_radius * math.cos(phi)
+                return (x, y, z)
+
+            # Step 3: Compute vertices for each cluster
+            object_positions = [None] * len(vertices)  # Placeholder list for ordered vertices
+            cluster_index = 0
+
+            for value, objs in grouped_objects.items():
+                # Determine the center of the current cluster
+                if value not in cluster_centers:
+                    cluster_center = generate_cluster_center(cluster_index, num_clusters, radius)
+                    cluster_centers[value] = cluster_center
+                    cluster_index += 1
+                else:
+                    cluster_center = cluster_centers[value]
+
+                intra_cluster_radius = radius*(len(objs)/len(vertices) + 0.1)
+
+                # Step 4: Place objects randomly within the cluster's spherical volume
+                for obj, original_index in objs:
+                    # Randomly place the object within the intra-cluster sphere
+                    u = random.random()
+                    v = random.random()
+                    r = intra_cluster_radius * (u ** (1/3))  # Random distance with cube root for uniform distribution
+
+                    theta = 2 * math.pi * v  # Random azimuthal angle
+                    phi = math.acos(2 * u - 1)  # Random polar angle
+
+                    # Spherical to Cartesian for local positioning
+                    x = cluster_center[0] + r * math.sin(phi) * math.cos(theta)
+                    y = cluster_center[1] + r * math.sin(phi) * math.sin(theta)
+                    z = cluster_center[2] + r * math.cos(phi)
+
+                    # Save the coordinates in the correct order
+                    object_positions[original_index] = [x, y, z]
+
+            positions = [[p[0], p[1], p[2]] for p in object_positions]
+            new_g = Graph.ByMeshData(positions, edges, v_dicts, e_dicts, tolerance=0.001)
+            return new_g
+
+        def sphere_layout_3d(graph, radius=0.5):
+            def points_on_sphere(n, r):
+                points = []
+                phi = math.pi * (3. - math.sqrt(5.))  # Golden angle in radians
 
+                for i in range(n):
+                    y = 1 - (i / float(n - 1)) * 2  # y goes from 1 to -1
+                    radius = math.sqrt(1 - y * y)    # radius at y
+
+                    theta = phi * i  # Golden angle increment
+
+                    x = math.cos(theta) * radius * r
+                    z = math.sin(theta) * radius * r
+                    y *= r
+
+                    points.append([x, y, z])
+                return points
+            
             vertices = Graph.Vertices(graph)
             edges = Graph.Edges(graph)
             edge_dict = {}
@@ -5734,16 +6082,15 @@ class Graph:
                 ei = Vertex.Index(ev, vertices)
                 edge_dict[str(si)+"_"+str(ei)] = i
                 edge_dict[str(ei)+"_"+str(si)] = i
-            
             n = len(vertices)
-            c = Wire.Circle(radius=radius, sides=n)
-            c_vertices = Topology.Vertices(c)
-
+            c_points = points_on_sphere(n, r=radius)
+            c_vertices = [Vertex.ByCoordinates(coord) for coord in c_points]
             for i, c_v in enumerate(c_vertices):
                 d = Topology.Dictionary(vertices[i])
                 c_v = Topology.SetDictionary(c_v, d)
             adj_dict = Graph.AdjacencyDictionary(graph)
             keys = adj_dict.keys()
+            
             c_edges = []
             used = [[0] * n for _ in range(n)]
             for key in keys:
@@ -5759,6 +6106,94 @@ class Graph:
                             e = Edge.ByVertices(c_vertices[x], c_vertices[y])
                         else:
                             e = Edge.ByVertices(c_vertices[y], c_vertices[x])
+                        orig_edge_index = edge_dict.get(str(x)+"_"+str(y), edge_dict.get(str(y)+"_"+str(x), None))
+                        if orig_edge_index:
+                            d = Topology.Dictionary(edges[orig_edge_index])
+                            e = Topology.SetDictionary(e, d)
+                            c_edges.append(e)
+                            used[x][y] = 1
+                            used[y][x] = 1
+            new_g = Graph.ByVerticesEdges(c_vertices, c_edges)
+            return new_g
+        
+        def grid_layout_2d(graph, size=1):
+            vertices = Graph.Vertices(graph)
+            n = len(vertices)
+            u = int(math.sqrt(n))
+            if u*u < n:
+                u += 1
+            u_range = [t/(u-1) for t in range(u)]            
+            edges = Graph.Edges(graph)
+            edge_dict = {}
+
+            for i, edge in enumerate(edges):
+                sv = Edge.StartVertex(edge)
+                ev = Edge.EndVertex(edge)
+                si = Vertex.Index(sv, vertices)
+                ei = Vertex.Index(ev, vertices)
+                edge_dict[str(si)+"_"+str(ei)] = i
+                edge_dict[str(ei)+"_"+str(si)] = i
+            f = Face.Rectangle(width=size, length=size)
+            c = Grid.VerticesByParameters(face=f, uRange=u_range, vRange=u_range)
+            c_vertices = Topology.Vertices(c)[:len(vertices)]
+
+            for i, c_v in enumerate(c_vertices):
+                d = Topology.Dictionary(vertices[i])
+                c_v = Topology.SetDictionary(c_v, d)
+            adj_dict = Graph.AdjacencyDictionary(graph)
+            keys = adj_dict.keys()
+            
+            c_edges = []
+            used = [[0] * n for _ in range(n)]
+            for key in keys:
+                x = int(key)
+                adj_vertices = [int(v) for v in adj_dict[key]]
+                for y in adj_vertices:
+                    if used[x][y] == 0:
+                        e = Edge.ByVertices(c_vertices[x], c_vertices[y])
+                        orig_edge_index = edge_dict.get(str(x)+"_"+str(y), edge_dict.get(str(y)+"_"+str(x), None))
+                        if orig_edge_index:
+                            d = Topology.Dictionary(edges[orig_edge_index])
+                            e = Topology.SetDictionary(e, d)
+                            c_edges.append(e)
+                            used[x][y] = 1
+                            used[y][x] = 1
+            new_g = Graph.ByVerticesEdges(c_vertices, c_edges)
+            return new_g
+
+        def line_layout_2d(graph, length=1):
+            vertices = Graph.Vertices(graph)
+            edges = Graph.Edges(graph)
+            edge_dict = {}
+
+            for i, edge in enumerate(edges):
+                sv = Edge.StartVertex(edge)
+                ev = Edge.EndVertex(edge)
+                si = Vertex.Index(sv, vertices)
+                ei = Vertex.Index(ev, vertices)
+                edge_dict[str(si)+"_"+str(ei)] = i
+                edge_dict[str(ei)+"_"+str(si)] = i
+            
+            n = len(vertices)
+            c = Wire.Line(length=length, sides=n-1)
+            c_vertices = Topology.Vertices(c)
+
+            for i, c_v in enumerate(c_vertices):
+                d = Topology.Dictionary(vertices[i])
+                c_v = Topology.SetDictionary(c_v, d)
+            adj_dict = Graph.AdjacencyDictionary(graph)
+            keys = adj_dict.keys()
+            c_edges = []
+            used = [[0] * n for _ in range(n)]
+            for key in keys:
+                x = int(key)
+                adj_vertices = [int(v) for v in adj_dict[key]]
+                for y in adj_vertices:
+                    if used[x][y] == 0:
+                        if Vertex.X(c_vertices[x]) < Vertex.X(c_vertices[y]):
+                            e = Edge.ByVertices(c_vertices[x], c_vertices[y])
+                        else:
+                            e = Edge.ByVertices(c_vertices[y], c_vertices[x])
                         
                         orig_edge_index = edge_dict[str(x)+"_"+str(y)]
                         d = Topology.Dictionary(edges[orig_edge_index])
@@ -5769,10 +6204,51 @@ class Graph:
             new_g = Graph.ByVerticesEdges(c_vertices, c_edges)
             return new_g
         
-        def spring_layout(edge_list, iterations=500, k=None, seed=None):
-            # Compute the layout of a graph using the Fruchterman-Reingold algorithm
-            # with a force-directed layout approach.
+        def grid_layout_3d(graph, size=1):
+            vertices = Graph.Vertices(graph)
+            n = len(vertices)        
+            edges = Graph.Edges(graph)
+            edge_dict = {}
 
+            for i, edge in enumerate(edges):
+                sv = Edge.StartVertex(edge)
+                ev = Edge.EndVertex(edge)
+                si = Vertex.Index(sv, vertices)
+                ei = Vertex.Index(ev, vertices)
+                edge_dict[str(si)+"_"+str(ei)] = i
+                edge_dict[str(ei)+"_"+str(si)] = i
+            c_coords = generate_cubic_matrix(size, n)
+            c_vertices = [Vertex.ByCoordinates(list(coord)) for coord in c_coords[:n]]
+
+            for i, c_v in enumerate(c_vertices):
+                d = Topology.Dictionary(vertices[i])
+                c_v = Topology.SetDictionary(c_v, d)
+            adj_dict = Graph.AdjacencyDictionary(graph)
+            keys = adj_dict.keys()
+            
+            c_edges = []
+            used = [[0] * n for _ in range(n)]
+            for key in keys:
+                x = int(key)
+                adj_vertices = [int(v) for v in adj_dict[key]]
+                for y in adj_vertices:
+                    if used[x][y] == 0:
+                        e = Edge.ByVertices(c_vertices[x], c_vertices[y])
+                        orig_edge_index = edge_dict.get(str(x)+"_"+str(y), edge_dict.get(str(y)+"_"+str(x), None))
+                        if orig_edge_index:
+                            d = Topology.Dictionary(edges[orig_edge_index])
+                            e = Topology.SetDictionary(e, d)
+                            c_edges.append(e)
+                            used[x][y] = 1
+                            used[y][x] = 1
+            new_g = Graph.ByVerticesEdges(c_vertices, c_edges)
+            return new_g
+    
+        def spring_layout_2d(edge_list, iterations=500, k=None, seed=None):
+            # Compute the layout of a graph using the Fruchterman-Reingold algorithm
+            # with a force-directed 
+            
+            iterations = max(1, iterations)
             adj_matrix = edge_list_to_adjacency_matrix(edge_list)
             # Set the random seed
             if seed is not None:
@@ -5820,7 +6296,60 @@ class Graph:
 
             return pos
 
-        def tree_layout(edge_list,  root_index=0):
+        def spring_layout_3d(edge_list, iterations=500, k=None, seed=None):
+            # Compute the layout of a graph using the Fruchterman-Reingold algorithm
+            # with a force-directed layout approach.
+
+            iterations = max(1,iterations)
+
+            adj_matrix = edge_list_to_adjacency_matrix(edge_list)
+            # Set the random seed
+            if seed is not None:
+                np.random.seed(seed)
+
+            # Set the optimal distance between nodes
+            if k is None or k <= 0:
+                k = np.cbrt(1.0 / adj_matrix.shape[0])  # Adjusted for 3D
+
+            # Initialize the positions of the nodes randomly in 3D
+            pos = np.random.rand(adj_matrix.shape[0], 3)
+
+            # Compute the initial temperature
+            t = 0.1 * np.max(pos)
+
+            # Compute the cooling factor
+            cooling_factor = t / iterations
+
+            # Iterate over the specified number of iterations
+            for i in range(iterations):
+                # Compute the distance between each pair of nodes
+                delta = pos[:, np.newaxis, :] - pos[np.newaxis, :, :]
+                distance = np.linalg.norm(delta, axis=-1)
+
+                # Avoid division by zero
+                distance = np.where(distance == 0, 0.1, distance)
+
+                # Compute the repulsive force between each pair of nodes
+                repulsive_force = k ** 2 / distance ** 2
+
+                # Compute the attractive force between each pair of adjacent nodes
+                attractive_force = adj_matrix * distance / k
+
+                # Compute the total force acting on each node
+                force = np.sum((repulsive_force - attractive_force)[:, :, np.newaxis] * delta, axis=1)
+
+                # Compute the displacement of each node
+                displacement = t * force / np.linalg.norm(force, axis=1)[:, np.newaxis]
+
+                # Update the positions of the nodes
+                pos += displacement
+
+                # Cool the temperature
+                t -= cooling_factor
+
+            return pos
+
+        def tree_layout_2d(edge_list,  root_index=0):
 
             root, num_nodes = tree_from_edge_list(edge_list, root_index)
             dt = buchheim(root)
@@ -5846,8 +6375,46 @@ class Graph:
             pos[:, 1] = np.max(pos[:, 1]) - pos[:, 1]
             
             return pos
+        
+        def tree_layout_3d(edge_list, root_index=0, base_radius=1.0, radius_factor=1.5):
+            root, num_nodes = tree_from_edge_list(edge_list, root_index)
+            dt = buchheim(root)
+            pos = np.zeros((num_nodes, 3))  # Initialize 3D positions
+            
+            pos[int(dt.tree.node), 0] = dt.x
+            pos[int(dt.tree.node), 1] = dt.y
+            pos[int(dt.tree.node), 2] = 0  # Root at z = 0
+            
+            old_roots = [dt]
+            new_roots = []
+            depth = 1  # Start at depth level 1 for children
+
+            while len(old_roots) > 0:
+                new_roots = []
+                for temp_root in old_roots:
+                    children = temp_root.children
+                    num_children = len(children)
+                    if num_children > 0:
+                        # Increase the radius dynamically based on the number of children
+                        dynamic_radius = base_radius + (num_children - 1) * radius_factor * depth
+                        
+                        angle_step = 2 * np.pi / num_children  # Angle between each child
+                        for i, child in enumerate(children):
+                            angle = i * angle_step
+                            pos[int(child.tree.node), 0] = pos[int(temp_root.tree.node), 0] + dynamic_radius * np.cos(angle)  # X position
+                            pos[int(child.tree.node), 1] = pos[int(temp_root.tree.node), 1] + dynamic_radius * np.sin(angle)  # Y position
+                            pos[int(child.tree.node), 2] = -dynamic_radius*depth  # Z-coordinate based on depth
+                            
+                    new_roots.extend(children)
+                
+                old_roots = new_roots
+                depth += 1  # Increment depth for the next level
+
+            pos[:, 1] = np.max(pos[:, 1]) - pos[:, 1]  # Flip y-coordinates if necessary
+
+            return pos
 
-        def radial_layout(edge_list, root_index=0):
+        def radial_layout_2d(edge_list, root_index=0):
             root, num_nodes = tree_from_edge_list(edge_list, root_index)
             dt = buchheim(root)
             pos = np.zeros((num_nodes, 2))
@@ -5888,53 +6455,119 @@ class Graph:
             
             return new_pos
 
-        def graph_layout(edge_list, layout='tree', root_index=0, k=None, seed=None, iterations=500):
+        def spherical_layout_3d(edge_list, root_index=0):
+            root, num_nodes = tree_from_edge_list(edge_list, root_index)
+            dt = buchheim(root)
 
-            if layout == 'tree':
-                return tree_layout(edge_list, root_index=root_index)
-            elif layout == 'spring':
-                return spring_layout(edge_list, k=k, seed=seed, iterations=iterations)
-            elif layout == 'radial':
-                return radial_layout(edge_list, root_index=root_index)
-            else:
-                raise NotImplementedError(f"{layout} is not implemented yet. Please choose from ['radial', 'spring', 'tree']")
+            # Initialize positions with 3 columns for x, y, z coordinates
+            pos = np.zeros((num_nodes, 3))
 
-        def vertex_max_degree(graph, vertices):
-            degrees = [Graph.VertexDegree(graph, vertex) for vertex in vertices]
-            i = degrees.index(max(degrees))
-            return vertices[i], i
+            # Set initial coordinates and depth for the root node
+            pos[int(dt.tree.node), 0] = dt.x
+            pos[int(dt.tree.node), 1] = dt.y
+            depth = np.zeros(num_nodes)  # To track the depth of each node
+
+            old_roots = [(dt, 0)]  # Store nodes with their depth levels
+            new_roots = []
+
+            while len(old_roots) > 0:
+                new_roots = []
+                for temp_root, current_depth in old_roots:
+                    children = temp_root.children
+                    for child in children:
+                        node_index = int(child.tree.node)
+                        pos[node_index, 0] = child.x
+                        pos[node_index, 1] = child.y
+                        depth[node_index] = current_depth + 1  # Increase depth for children
+                    new_roots.extend([(child, current_depth + 1) for child in children])
+
+                old_roots = new_roots
+
+            # Normalize x and y coordinates to a [0, 1] range
+            pos[:, 0] = pos[:, 0] - np.min(pos[:, 0])
+            pos[:, 1] = pos[:, 1] - np.min(pos[:, 1])
+
+            pos[:, 0] = pos[:, 0] / np.max(pos[:, 0])
+            pos[:, 0] = pos[:, 0] - pos[:, 0][root_index]
+            
+            range_ = np.max(pos[:, 0]) - np.min(pos[:, 0])
+            pos[:, 0] = pos[:, 0] / range_
+
+            pos[:, 0] = pos[:, 0] * np.pi * 1.98  # Longitude (azimuthal angle)
+            pos[:, 1] = pos[:, 1] / np.max(pos[:, 1])  # Latitude (polar angle)
+
+            # Convert the 2D coordinates to 3D spherical coordinates
+            new_pos = np.zeros((num_nodes, 3))  # 3D position array
+            base_radius = 1  # Base radius for the first sphere
+            radius_increment = 1.3  # Increase in radius per depth level
+
+            # pos[:, 0] is the azimuth angle (longitude) in radians
+            # pos[:, 1] is the polar angle (latitude) in radians (adjusted to go from 0 to pi)
+            polar_angle = pos[:, 1] * np.pi  # Scaling to go from 0 to pi
+            azimuth_angle = pos[:, 0]
+
+            # Calculate the 3D Cartesian coordinates based on depth
+            for i in range(num_nodes):
+                r = base_radius + depth[i] * radius_increment  # Radius grows with depth
+                new_pos[i, 0] = r * np.sin(polar_angle[i]) * np.cos(azimuth_angle[i])  # X = r * sin(θ) * cos(φ)
+                new_pos[i, 1] = r * np.sin(polar_angle[i]) * np.sin(azimuth_angle[i])  # Y = r * sin(θ) * sin(φ)
+                new_pos[i, 2] = r * np.cos(polar_angle[i])  # Z = r * cos(θ)
+
+            return new_pos
 
         if not Topology.IsInstance(graph, "Graph"):
-            print("Graph.Flatten - Error: The input graph is not a valid topologic graph. Returning None.")
+            if not silent:
+                print("Graph.Flatten - Error: The input graph is not a valid topologic graph. Returning None.")
             return None
         
-        if 'circ' in layout.lower():
-            new_graph = circle_layout(graph, radius=radius)
-            return new_graph
-        d = Graph.MeshData(graph)
-        vertices = d['vertices']
-        edges = d['edges']
-        v_dicts = d['vertexDictionaries']
-        e_dicts = d['edgeDictionaries']
-        vertices = Graph.Vertices(graph)
-        if rootVertex == None:
-            rootVertex, root_index = vertex_max_degree(graph, vertices)
+        if 'circ' in shape.lower():
+            return circle_layout_2d(graph, radius=size/2, sides=sides)
+        elif 'lin' in shape.lower():
+            return line_layout_2d(graph, length=size)
+        elif 'grid' in shape.lower() and '2d' in shape.lower():
+            return grid_layout_2d(graph, size=size)
+        elif 'sphere' == shape.lower() and '3d' in shape.lower():
+            return sphere_layout_3d(graph, radius=size/2)
+        elif 'grid' in shape.lower() and '3d' in shape.lower():
+            return grid_layout_3d(graph, size=size)
+        elif 'cluster' in shape.lower() and '2d' in shape.lower():
+            return cluster_layout_2d(graph, radius=size/2, key=key)
+        elif 'cluster' in shape.lower() and '3d' in shape.lower():
+            return cluster_layout_3d(graph, radius=size/2, key=key)
         else:
-            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():
-            positions = spring_layout(edges, k=k, seed=seed, iterations=iterations)
-        elif 'tree' in layout.lower():
-            positions = tree_layout(edges, root_index=root_index)
-        else:
-            raise NotImplementedError(f"{layout} is not implemented yet. Please choose from ['radial', 'spring', 'tree']")
-        positions = positions.tolist()
-        positions = [[p[0], p[1], 0] for p in positions]
-        flat_graph = Graph.ByMeshData(positions, edges, v_dicts, e_dicts, tolerance=tolerance)
-        return flat_graph
+            d = Graph.MeshData(graph)
+            edges = d['edges']
+            v_dicts = d['vertexDictionaries']
+            e_dicts = d['edgeDictionaries']
+            vertices = Graph.Vertices(graph)
+            if rootVertex == None:
+                rootVertex, root_index = vertex_max_degree(graph, vertices)
+            else:
+                root_index = Vertex.Index(rootVertex, vertices, tolerance=tolerance)
+            if root_index == None:
+                root_index = 0
+            if 'rad' in shape.lower() and '2d' in shape.lower():
+                positions = radial_layout_2d(edges, root_index=root_index)
+            elif 'spherical' in shape.lower() and '3d' in shape.lower():
+                positions = spherical_layout_3d(edges, root_index=root_index)
+            elif 'spring' in shape.lower() and "3d" in shape.lower():
+                positions = spring_layout_3d(edges, k=k, seed=seed, iterations=iterations)
+            elif 'spring' in shape.lower() and '2d' in shape.lower():
+                positions = spring_layout_2d(edges, k=k, seed=seed, iterations=iterations)
+            elif 'tree' in shape.lower() and '2d' in shape.lower():
+                positions = tree_layout_2d(edges, root_index=root_index)
+            elif 'tree' in shape.lower() and '3d' in shape.lower():
+                positions = tree_layout_3d(edges, root_index=root_index, base_radius=1.0, radius_factor=1.5)
+            else:
+                if not silent:
+                    print(f"{shape} is not implemented yet. Please choose from ['circle 2D', 'grid 2D', 'line 2D', 'radial 2D', 'spring 2D', 'tree 2D', 'grid 3D', 'sphere 3D', 'tree 3D']. Returning None.")
+                return None
+            positions = positions.tolist()
+            if len(positions[0]) == 3:
+                positions = [[p[0], p[1], p[2]] for p in positions]
+            else:
+                positions = [[p[0], p[1], 0] for p in positions]
+            return Graph.ByMeshData(positions, edges, v_dicts, e_dicts, tolerance=tolerance)
 
     @staticmethod
     def GlobalClusteringCoefficient(graph):

topologicpy/Plotly.py

@@ -415,23 +415,24 @@ class Plotly:
             e_cluster = Cluster.ByTopologies(vertices)
             geo = Topology.Geometry(e_cluster, mantissa=mantissa)
             vertices = geo['vertices']
-            v_data = Plotly.DataByTopology(e_cluster,
-                                    vertexColor=vertexColor,
-                                    vertexColorKey=vertexColorKey,
-                                    vertexSize=vertexSize,
-                                    vertexSizeKey=vertexSizeKey,
-                                    vertexLabelKey=vertexLabelKey,
-                                    showVertexLabel=showVertexLabel,
-                                    vertexGroupKey=vertexGroupKey,
-                                    vertexMinGroup=vertexMinGroup,
-                                    vertexMaxGroup=vertexMaxGroup,
-                                    vertexGroups=vertexGroups,
-                                    vertexLegendLabel=vertexLegendLabel,
-                                    vertexLegendGroup=vertexLegendGroup,
-                                    vertexLegendRank=vertexLegendRank,
-                                    colorScale=colorScale)
-
-            data += v_data
+            if len(vertices) > 0:
+                v_data = Plotly.DataByTopology(e_cluster,
+                                        vertexColor=vertexColor,
+                                        vertexColorKey=vertexColorKey,
+                                        vertexSize=vertexSize,
+                                        vertexSizeKey=vertexSizeKey,
+                                        vertexLabelKey=vertexLabelKey,
+                                        showVertexLabel=showVertexLabel,
+                                        vertexGroupKey=vertexGroupKey,
+                                        vertexMinGroup=vertexMinGroup,
+                                        vertexMaxGroup=vertexMaxGroup,
+                                        vertexGroups=vertexGroups,
+                                        vertexLegendLabel=vertexLegendLabel,
+                                        vertexLegendGroup=vertexLegendGroup,
+                                        vertexLegendRank=vertexLegendRank,
+                                        colorScale=colorScale)
+
+                data += v_data
         
         if showEdges:
             e_dictionaries = []
@@ -458,12 +459,12 @@ class Plotly:
                 else:
                     new_edges = edges
                     e_dictionaries.append(d)
-
-            e_cluster = Cluster.ByTopologies(new_edges)
-            geo = Topology.Geometry(e_cluster, mantissa=mantissa)
-            vertices = geo['vertices']
-            edges = geo['edges']
-            data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))        
+            if len(new_edges) > 0:
+                e_cluster = Cluster.ByTopologies(new_edges)
+                geo = Topology.Geometry(e_cluster, mantissa=mantissa)
+                vertices = geo['vertices']
+                edges = geo['edges']
+                data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))        
         return data
     
     @staticmethod
@@ -496,7 +497,7 @@ class Plotly:
                 x.append(v[0])
                 y.append(v[1])
                 z.append(v[2])
-                label = ""
+                label = " "
                 group = None
                 if len(dictionaries) > 0:
                     d = dictionaries[m]
@@ -506,15 +507,13 @@ class Plotly:
                             color = Color.AnyToHex(d_color)
                             groupList.append(color)
                         if not labelKey == None:
-                            label = str(Dictionary.ValueAtKey(d, key=labelKey)) or ""
+                            label = str(Dictionary.ValueAtKey(d, key=labelKey)) or " "
                         if not sizeKey == None:
                             size = Dictionary.ValueAtKey(d, key=sizeKey) or size
                         if not groupKey == None:
-                            group = Dictionary.ValueAtKey(d, key=groupKey) or ""
+                            group = Dictionary.ValueAtKey(d, key=groupKey) or " "
                     try:
-                        if group == "":
-                            #color = 'white'
-                            #groupList.append(Color.AnyToHex(color))
+                        if group == " ":
                             pass
                         elif type(group) == int or type(group) == float:
                             if group < minGroup:
@@ -571,8 +570,6 @@ class Plotly:
         from topologicpy.Color import Color
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Helper import Helper
-        for d in dictionaries[:30]:
-            print(Dictionary.Keys(d), Dictionary.Values(d))
         traces = []
         x = []
         y = []
@@ -855,121 +852,6 @@ class Plotly:
         def closest_index(input_value, values):
             return int(min(range(len(values)), key=lambda i: abs(values[i] - input_value)))
 
-        def edgeData_old(vertices, edges, dictionaries=None, color="black", colorKey=None, width=1, widthKey=None, labelKey=None, showEdgeLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Edges", legendGroup=2, legendRank=2, showLegend=True, colorScale="Viridis"):
-            traces = []
-            x = []
-            y = []
-            z = []
-            labels = []
-            groupList = []
-            label = ""
-            group = ""
-
-            if showEdgeLabel == True:
-                mode = "lines+text"
-            else:
-                mode = "lines"
-            
-            if showEdgeLabel == True:
-                mode = "lines+text"
-            else:
-                mode = "lines"
-            if groups:
-                if len(groups) > 0:
-                    if type(groups[0]) == int or type(groups[0]) == float:
-                        if not minGroup:
-                            minGroup = min(groups)
-                        if not maxGroup:
-                            maxGroup = max(groups)
-                    else:
-                        minGroup = 0
-                        maxGroup = len(groups) - 1
-            else:
-                minGroup = 0
-                maxGroup = 1
-
-            if colorKey or widthKey or labelKey or groupKey:
-                keys = [x for x in [colorKey, widthKey, labelKey, groupKey] if not x == None]
-                temp_dict = Helper.ClusterByKeys(edges, dictionaries, keys, silent=False)
-                dict_clusters = temp_dict["dictionaries"]
-                elements_clusters = temp_dict['elements']
-                for j, elements_cluster in enumerate(elements_clusters):
-                    d = dict_clusters[j][0] # All dicitonaries have same values in dictionaries, so take first one.
-                    if d:
-                        if not colorKey == None:
-                            d_color = Dictionary.ValueAtKey(d, key=colorKey) or color
-                            color = Color.AnyToHex(d_color)
-                        if not labelKey == None:
-                            label = str(Dictionary.ValueAtKey(d, key=labelKey)) or ""
-                        if not widthKey == None:
-                            width = Dictionary.ValueAtKey(d, key=edgeWidthKey) or width
-                        if not groupKey == None:
-                            group = Dictionary.ValueAtKey(d, key=groupKey)
-                            if not group == None:
-                                if type(group) == int or type(group) == float:
-                                    if group < minGroup:
-                                        group = minGroup
-                                    if group > maxGroup:
-                                        group = maxGroup
-                                    d_color = Color.ByValueInRange(group, minValue=minGroup, maxValue=maxGroup, colorScale=colorScale)
-                                else:
-                                    d_color = Color.ByValueInRange(groups.index(group), minValue=minGroup, maxValue=maxGroup, colorScale=colorScale)
-                                color = d_color
-                    x = []
-                    y = []
-                    z = []
-                    for e in elements_cluster:
-                        sv = vertices[e[0]]
-                        ev = vertices[e[1]]
-                        x+=[sv[0], ev[0], None] # x-coordinates of edge ends
-                        y+=[sv[1], ev[1], None] # y-coordinates of edge ends
-                        z+=[sv[2], ev[2], None] # z-coordinates of edge ends
-                    if showEdgeLabel == True:
-                        mode = "lines+text"
-                    else:
-                        mode = "lines"
-                    trace = go.Scatter3d(x=x,
-                                        y=y,
-                                        z=z,
-                                        name=label,
-                                        showlegend=showLegend,
-                                        marker_size=0,
-                                        mode=mode,
-                                        line=dict(color=color, width=width),
-                                        legendgroup=legendGroup,
-                                        legendrank=legendRank,
-                                        text=label,
-                                        hoverinfo='text')
-                    traces.append(trace)
-            else:
-                x = []
-                y = []
-                z = []
-                for e in edges:
-                    sv = vertices[e[0]]
-                    ev = vertices[e[1]]
-                    x+=[sv[0], ev[0], None] # x-coordinates of edge ends
-                    y+=[sv[1], ev[1], None] # y-coordinates of edge ends
-                    z+=[sv[2], ev[2], None] # z-coordinates of edge ends
-                if showEdgeLabel == True:
-                    mode = "lines+text"
-                else:
-                    mode = "lines"
-                trace = go.Scatter3d(x=x,
-                                    y=y,
-                                    z=z,
-                                    name=label,
-                                    showlegend=showLegend,
-                                    marker_size=0,
-                                    mode=mode,
-                                    line=dict(color=color, width=width),
-                                    legendgroup=legendGroup,
-                                    legendrank=legendRank,
-                                    text=label,
-                                    hoverinfo='text')
-                traces.append(trace)
-
-            return traces
 
         def faceData(vertices, faces, dictionaries=None, color="#FAFAFA", colorKey=None,
                      opacity=0.5, labelKey=None, groupKey=None,
@@ -1152,7 +1034,8 @@ class Plotly:
                 geo = Topology.Geometry(e_cluster, mantissa=mantissa)
                 vertices = geo['vertices']
                 edges = geo['edges']
-                data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))
+                if len(edges) > 0:
+                    data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))
         
         if showFaces and Topology.Type(topology) >= Topology.TypeID("Face"):
             if not faceColorKey == None:
@@ -1185,7 +1068,8 @@ class Plotly:
                     geo = Topology.Geometry(f_cluster, mantissa=mantissa)
                     vertices = geo['vertices']
                     faces = geo['faces']
-                    data.append(faceData(vertices, faces, dictionaries=f_dictionaries, color=faceColor, colorKey=faceColorKey, opacity=faceOpacity, labelKey=faceLabelKey, groupKey=faceGroupKey, minGroup=faceMinGroup, maxGroup=faceMaxGroup, groups=faceGroups, legendLabel=faceLegendLabel, legendGroup=faceLegendGroup, legendRank=faceLegendRank, showLegend=showFaceLegend, intensities=intensityList, colorScale=colorScale))
+                    if len(faces) > 0:
+                        data.append(faceData(vertices, faces, dictionaries=f_dictionaries, color=faceColor, colorKey=faceColorKey, opacity=faceOpacity, labelKey=faceLabelKey, groupKey=faceGroupKey, minGroup=faceMinGroup, maxGroup=faceMaxGroup, groups=faceGroups, legendLabel=faceLegendLabel, legendGroup=faceLegendGroup, legendRank=faceLegendRank, showLegend=showFaceLegend, intensities=intensityList, colorScale=colorScale))
         return data
 
     @staticmethod

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.72'
+__version__ = '0.7.74'

{topologicpy-0.7.72.dist-info → topologicpy-0.7.74.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.72
+Version: 0.7.74
 Summary: An AI-Powered Spatial Modelling and Analysis Software Library for Architecture, Engineering, and Construction.
 Author-email: Wassim Jabi <wassim.jabi@gmail.com>
 License: AGPL v3 License

{topologicpy-0.7.72.dist-info → topologicpy-0.7.74.dist-info}/RECORD

@@ -2,7 +2,7 @@ topologicpy/ANN.py,sha256=XAuUjNvDRK1hhXfo82S-zXmnAPZGEdHJMRdfpu0aJ8I,47901
 topologicpy/Aperture.py,sha256=p9pUzTQSBWoUaDiug1V1R1hnEIEwYSXFg2t7iRAmNRY,2723
 topologicpy/BVH.py,sha256=mKVCAu9K8qzcWXtPDVH5usXZV1DNNNJl4n3rU5Lh1ZM,12931
 topologicpy/Cell.py,sha256=2izd-YGqy897_JHHgrGlIo5WwUeEIWVD3KspV1z_sj8,107860
-topologicpy/CellComplex.py,sha256=x3Exodx2PeXynnnqzb3ZLKtlSdey8KaaiKpkcx8HoCc,48207
+topologicpy/CellComplex.py,sha256=5PtnRrDx_3zmtt4aTosxK9XBzZtayzaOC50pkJiIlFY,51170
 topologicpy/Cluster.py,sha256=51q5G1L5xAzRMfVU8YBXhq0g3g2X9aVNcahU-vYZRrI,55672
 topologicpy/Color.py,sha256=wPhA7rLr9BTZsWYUUVnQpbmL5ZMkGlDSsa8f3S5B-d4,20250
 topologicpy/Context.py,sha256=ppApYKngZZCQBFWaxIMi2z2dokY23c935IDCBosxDAE,3055
@@ -11,13 +11,13 @@ topologicpy/Dictionary.py,sha256=0AsGoz48pGTye_F4KcJopNjD9STeQ50LHc6PPvERFaA,319
 topologicpy/Edge.py,sha256=9u9SdUxuenLUIK26xwFvPoYV34p0dCfXmHHBxdgvAdM,67164
 topologicpy/EnergyModel.py,sha256=AqTtmXE35SxvRXhG3vYAQd7GQDW-6HtjYPHua6ME4Eg,53762
 topologicpy/Face.py,sha256=q7x6auTju6IS3mdOhhXZdU3rqKSuJCE-5EOfxofDDMI,124348
-topologicpy/Graph.py,sha256=M4m0URB812Fb8ISdiSftaZ-XJv8tOHY9eeba43-C6W0,386261
+topologicpy/Graph.py,sha256=BuSg8ilbZd2Qqoenmtw5FrkSe1fDLFS6jshljvq4dOs,416822
 topologicpy/Grid.py,sha256=9N6PE84qCm40TRi2WtlVZSBwXXr47zHpscEpZHg_JW4,18205
 topologicpy/Helper.py,sha256=Sv35czP_j0oLDeJcN8usswUm4U3auiK1LQ_Z_HBvxxg,21716
 topologicpy/Honeybee.py,sha256=HfTaEV1R8K1xOVQQy9sBOhBTF_ap8A2RxZOYhirp_Mw,21835
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=t52hgE9cVsqkGc7m7fjRsLnyfRHakVHwdvF4ms7ow78,22342
-topologicpy/Plotly.py,sha256=KU76pKFCfPUTmWMqMeyzbRbyri5VEPASKQZ9DQX4Evc,118323
+topologicpy/Plotly.py,sha256=VNUHRUNu4NUmf3HScQRml3TcwHe_ZoqXjqwttGSuU88,112642
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
 topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=8OJjlWk9eCZ3uGOTht6ZVrcMczCafw-YWoDGueaz7eg,87673
@@ -28,9 +28,9 @@ topologicpy/Vector.py,sha256=A1g83zDHep58iVPY8WQ8iHNrSOfGWFEzvVeDuMnjDNY,33078
 topologicpy/Vertex.py,sha256=ZS6xK89JKokBKc0W8frdRhhuzR8c-dI1TTLt7pTf1iA,71032
 topologicpy/Wire.py,sha256=eVet2OToVsXi9AkDYo35LpfMPqJ6aKGD6QkiU4-Jvs8,182271
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=aAQjVNTNHAmKloX4yKWiynz5GQOXtst-3Q4eQldJrXM,23
-topologicpy-0.7.72.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.72.dist-info/METADATA,sha256=Tj5f47D3-QD3OHRQDGyO-_BByNcAXuEWIEsdT6Nuob0,10493
-topologicpy-0.7.72.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-topologicpy-0.7.72.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.72.dist-info/RECORD,,
+topologicpy/version.py,sha256=_XwNUtWN5b4vRt6q08wKnk-7iLHDZXyRKXWBhgnWyP4,23
+topologicpy-0.7.74.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.74.dist-info/METADATA,sha256=QQ-v5awljewQVDPhAMmdZdVtUcKzJh4LRiYGoCePtmk,10493
+topologicpy-0.7.74.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+topologicpy-0.7.74.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.74.dist-info/RECORD,,

{topologicpy-0.7.72.dist-info → topologicpy-0.7.74.dist-info}/WHEEL

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