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

topologicpy/BVH.py

@@ -41,6 +41,8 @@ class BVH:
 
         def intersects(self, other):
             # Check if this AABB intersects with another AABB
+            if other == None:
+                return False
             return np.all(self.min_point <= other.max_point) and np.all(self.max_point >= other.min_point)
 
         def contains(self, point):
@@ -200,13 +202,13 @@ class BVH:
         cluster = Cluster.ByTopologies(vertices)
         bb = Topology.BoundingBox(cluster)
         d = Topology.Dictionary(bb)
-        min_x = Dictionary.ValueAtKey(d, "minx")
-        min_y = Dictionary.ValueAtKey(d, "miny")
-        min_z = Dictionary.ValueAtKey(d, "minz")
-        max_x = Dictionary.ValueAtKey(d, "maxx")
-        max_y = Dictionary.ValueAtKey(d, "maxy")
-        max_z = Dictionary.ValueAtKey(d, "maxz")
-        query_aabb = BVH.AABB(min_point=(min_x, min_y, min_z), max_point=(max_x,max_y,max_z))
+        x_min = Dictionary.ValueAtKey(d, "xmin")
+        y_min = Dictionary.ValueAtKey(d, "ymin")
+        z_min = Dictionary.ValueAtKey(d, "zmin")
+        x_max = Dictionary.ValueAtKey(d, "zmax")
+        y_max = Dictionary.ValueAtKey(d, "ymax")
+        z_max = Dictionary.ValueAtKey(d, "zmax")
+        query_aabb = BVH.AABB(min_point=(x_min, y_min, z_min), max_point=(x_max, y_max, z_max))
         return query_aabb
     
     def Clashes(bvh, query):

topologicpy/CellComplex.py

@@ -103,6 +103,8 @@ class CellComplex():
             If set to True, any dictionaries in the cells are transferred to the CellComplex. Otherwise, they are not. The default is False.
         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
         -------
@@ -192,7 +194,7 @@ class CellComplex():
         return CellComplex.ByCells(cells, tolerance)
 
     @staticmethod
-    def ByFaces(faces: list, tolerance: float = 0.0001):
+    def ByFaces(faces: list, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a cellcomplex by merging the input faces.
 
@@ -202,6 +204,8 @@ class CellComplex():
             The input faces.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -213,38 +217,45 @@ class CellComplex():
         from topologicpy.Topology import Topology
 
         if not isinstance(faces, list):
-            print("CellComplex.ByFaces - Error: The input faces parameter is not a valid list. Returning None.")
+            if not silent:
+                print("CellComplex.ByFaces - Error: The input faces parameter is not a valid list. Returning None.")
             return None
         faces = [x for x in faces if Topology.IsInstance(x, "Face")]
         if len(faces) < 1:
-            print("CellComplex.ByFaces - Error: The input faces parameter does not contain any valid faces. Returning None.")
+            if not silent:
+                print("CellComplex.ByFaces - Error: The input faces parameter does not contain any valid faces. Returning None.")
             return None
         try:
             cellComplex = topologic.CellComplex.ByFaces(faces, tolerance, False) # Hook to Core
         except:
             cellComplex = None
         if not cellComplex:
-            print("CellComplex.ByFaces - Warning: The default method failed. Attempting a workaround.")
+            if not silent:
+                print("CellComplex.ByFaces - Warning: The default method failed. Attempting a workaround.")
             cellComplex = faces[0]
             for i in range(1,len(faces)):
                 newCellComplex = None
                 try:
                     newCellComplex = cellComplex.Merge(faces[i], False, tolerance)
                 except:
-                    print("CellComplex.ByFaces - Warning: Failed to merge face #"+str(i)+". Skipping.")
+                    if not silent:
+                        print("CellComplex.ByFaces - Warning: Failed to merge face #"+str(i)+". Skipping.")
                 if newCellComplex:
                     cellComplex = newCellComplex
             if not Topology.Type(cellComplex) == Topology.TypeID("CellComplex"):
-                print("CellComplex.ByFaces - Warning: The input faces do not form a cellcomplex")
+                if not silent:
+                    print("CellComplex.ByFaces - Warning: The input faces do not form a cellcomplex")
                 if Topology.Type(cellComplex) == Topology.TypeID("Cluster"):
                     returnCellComplexes = Cluster.CellComplexes(cellComplex)
                     if len(returnCellComplexes) > 0:
                         return returnCellComplexes[0]
                     else:
-                        print("CellComplex.ByFaces - Error: Could not create a cellcomplex. Returning None.")
+                        if not silent:
+                            print("CellComplex.ByFaces - Error: Could not create a cellcomplex. Returning None.")
                         return None
                 else:
-                    print("CellComplex.ByFaces - Error: Could not create a cellcomplex. Returning None.")
+                    if not silent:
+                        print("CellComplex.ByFaces - Error: Could not create a cellcomplex. Returning None.")
                     return None
         else:
             return cellComplex
@@ -892,33 +903,33 @@ class CellComplex():
                 x.append(Vertex.X(aVertex, mantissa=mantissa))
                 y.append(Vertex.Y(aVertex, mantissa=mantissa))
                 z.append(Vertex.Z(aVertex, mantissa=mantissa))
-            minX = min(x)
-            minY = min(y)
-            minZ = min(z)
+            x_min = min(x)
+            y_min = min(y)
+            z_min = min(z)
             maxX = max(x)
             maxY = max(y)
             maxZ = max(z)
-            return [minX, minY, minZ, maxX, maxY, maxZ]
+            return [x_min, y_min, z_min, maxX, maxY, maxZ]
         
         def slice(topology, uSides, vSides, wSides):
-            minX, minY, minZ, maxX, maxY, maxZ = bb(topology)
-            centroid = Vertex.ByCoordinates(minX+(maxX-minX)*0.5, minY+(maxY-minY)*0.5, minZ+(maxZ-minZ)*0.5)
-            wOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), Vertex.Y(centroid, mantissa=mantissa), minZ)
-            wFace = Face.Rectangle(origin=wOrigin, width=(maxX-minX)*1.1, length=(maxY-minY)*1.1)
+            x_min, y_min, z_min, maxX, maxY, maxZ = bb(topology)
+            centroid = Vertex.ByCoordinates(x_min+(maxX-x_min)*0.5, y_min+(maxY-y_min)*0.5, z_min+(maxZ-z_min)*0.5)
+            wOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), Vertex.Y(centroid, mantissa=mantissa), z_min)
+            wFace = Face.Rectangle(origin=wOrigin, width=(maxX-x_min)*1.1, length=(maxY-y_min)*1.1)
             wFaces = []
-            wOffset = (maxZ-minZ)/wSides
+            wOffset = (maxZ-z_min)/wSides
             for i in range(wSides-1):
                 wFaces.append(Topology.Translate(wFace, 0,0,wOffset*(i+1)))
-            uOrigin = Vertex.ByCoordinates(minX, Vertex.Y(centroid, mantissa=mantissa), Vertex.Z(centroid, mantissa=mantissa))
-            uFace = Face.Rectangle(origin=uOrigin, width=(maxZ-minZ)*1.1, length=(maxY-minY)*1.1, direction=[1,0,0])
+            uOrigin = Vertex.ByCoordinates(x_min, Vertex.Y(centroid, mantissa=mantissa), Vertex.Z(centroid, mantissa=mantissa))
+            uFace = Face.Rectangle(origin=uOrigin, width=(maxZ-z_min)*1.1, length=(maxY-y_min)*1.1, direction=[1,0,0])
             uFaces = []
-            uOffset = (maxX-minX)/uSides
+            uOffset = (maxX-x_min)/uSides
             for i in range(uSides-1):
                 uFaces.append(Topology.Translate(uFace, uOffset*(i+1),0,0))
-            vOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), minY, Vertex.Z(centroid, mantissa=mantissa))
-            vFace = Face.Rectangle(origin=vOrigin, width=(maxX-minX)*1.1, length=(maxZ-minZ)*1.1, direction=[0,1,0])
+            vOrigin = Vertex.ByCoordinates(Vertex.X(centroid, mantissa=mantissa), y_min, Vertex.Z(centroid, mantissa=mantissa))
+            vFace = Face.Rectangle(origin=vOrigin, width=(maxX-x_min)*1.1, length=(maxZ-z_min)*1.1, direction=[0,1,0])
             vFaces = []
-            vOffset = (maxY-minY)/vSides
+            vOffset = (maxY-y_min)/vSides
             for i in range(vSides-1):
                 vFaces.append(Topology.Translate(vFace, 0,vOffset*(i+1),0))
             all_faces = uFaces+vFaces+wFaces

topologicpy/Cluster.py

@@ -166,7 +166,7 @@ class Cluster():
         from topologicpy.Topology import Topology
         from topologicpy.Helper import Helper
         import inspect
-
+        
         if len(args) == 0:
             if not silent:
                 print("Cluster.ByTopologies - Error: The input topologies parameter is an empty list. Returning None.")

topologicpy/Color.py

@@ -18,6 +18,44 @@ import plotly.colors
 import math
 
 class Color:
+
+    @staticmethod
+    def AnyToHex(color):
+        """
+        Converts a color to a hexadecimal color string.
+
+        Parameters
+        ----------
+        color : list or str
+            The input color parameter which can be any of RGB, CMYK, CSS Named Color, or Hex
+
+        Returns
+        -------
+        str
+            A hexadecimal color string in the format '#RRGGBB'.
+        """
+        return_hex = None
+        if isinstance(color, list):
+            if len(color) == 4: # Probably CMYK
+                if all(0 <= x <= 1 for x in color[:4]):
+                    return_hex = Color.CMYKToHex(color[:4])
+            elif len(color) == 3:
+                if all(0 <= x <= 255 for x in color[:3]):
+                    return_hex = Color.RGBToHex(color[:3])
+        elif isinstance(color, str): # Probably a CSSColor
+            if color.lower() in [x.lower() for x in Color.CSSNamedColors()]:
+                rgb = Color.ByCSSNamedColor(color.lower())
+                return_hex = Color.RGBToHex(rgb)
+            else: # Probably alread a HEX or other Plotly-compatible string
+                return_hex = color
+
+        if not isinstance(return_hex, str):
+            print("Color.AnyToHex - Error: Could not recognize the input parameter. Returning None.")
+            return None
+
+        return return_hex.upper()
+    
+    
     @staticmethod
     def ByCSSNamedColor(color, alpha: float = None):
         """
@@ -262,6 +300,34 @@ class Color:
             rgbList.append(alpha)
         return rgbList
     
+    @staticmethod
+    def CMYKToHex(cmyk):
+        """
+        Convert a CMYK color (list of 4 values) to its hexadecimal representation.
+        
+        Parameters
+        ----------
+        color : list
+            cmyk (list or tuple): CMYK color values as [C, M, Y, K], each in the range 0 to 1.
+
+        Returns
+        -------
+        str: The hexadecimal color string for Plotly (e.g., '#FFFFFF').
+        """
+        c, m, y, k = cmyk
+        
+        # Convert CMYK to RGB
+        r = 255 * (1 - c) * (1 - k)
+        g = 255 * (1 - m) * (1 - k)
+        b = 255 * (1 - y) * (1 - k)
+        
+        # Clamp RGB values to 0-255 range and convert to integers
+        r, g, b = int(round(r)), int(round(g)), int(round(b))
+        
+        # Convert RGB to hex format
+        hex_color = "#{:02x}{:02x}{:02x}".format(r, g, b)
+        return hex_color
+    
     @staticmethod
     def CSSNamedColor(color):
         """
@@ -355,7 +421,7 @@ class Color:
             "mediumorchid", "mediumpurple", "mediumseagreen", "mediumslateblue", "mediumspringgreen", "mediumturquoise",
             "mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin", "navajowhite", "navy", "oldlace",
             "olive", "olivedrab", "orange", "orangered", "orchid", "palegoldenrod", "palegreen", "paleturquoise",
-            "palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue", "purple", "rebeccapurple",
+            "palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue", "purple",
             "red", "rosybrown", "royalblue", "saddlebrown", "salmon", "sandybrown", "seagreen", "seashell", "sienna",
             "silver", "skyblue", "slateblue", "slategray", "slategrey", "snow", "springgreen", "steelblue", "tan",
             "teal", "thistle", "tomato", "turquoise", "violet", "wheat", "white", "whitesmoke", "yellow", "yellowgreen"

topologicpy/Dictionary.py

@@ -344,6 +344,97 @@ class Dictionary():
             values.append(pythonDictionary[key])
         return Dictionary.ByKeysValues(keys, values)
 
+    @staticmethod
+    def Filter(elements, dictionaries, searchType="any", key=None, value=None):
+        """
+        Filters the input list of dictionaries based on the input parameters.
+
+        Parameters
+        ----------
+        elements : list
+            The input list of elements to be filtered according to the input dictionaries.
+        dictionaries : list
+            The input list of dictionaries to be filtered.
+        searchType : str , optional
+            The type of search query to conduct in the topology's dictionary. This can be one of "any", "equal to", "contains", "starts with", "ends with", "not equal to", "does not contain". The default is "any".
+        key : str , optional
+            The dictionary key to search within. The default is None which means it will filter by topology type only.
+        value : str , optional
+            The value to search for at the specified key. The default is None which means it will filter by topology type only.
+
+        Returns
+        -------
+        dict
+            A dictionary of filtered and other elements. The dictionary has two keys:
+            - "filtered" The filtered dictionaries.
+            - "other" The other dictionaries that did not meet the filter criteria.
+            - "filteredIndices" The filtered indices of dictionaries.
+            - "otherIndices" The other indices of dictionaries that did not meet the filter criteria.
+
+        """
+
+        from topologicpy.Topology import Topology
+
+        def listToString(item):
+            returnString = ""
+            if isinstance(item, list):
+                if len(item) < 2:
+                    return str(item[0])
+                else:
+                    returnString = item[0]
+                    for i in range(1, len(item)):
+                        returnString = returnString+str(item[i])
+            return returnString
+        
+        filteredDictionaries = []
+        otherDictionaries = []
+        filteredElements = []
+        otherElements = []
+        filteredIndices = []
+        otherIndices = []
+        for i, aDictionary in enumerate(dictionaries):
+            if not Topology.IsInstance(aDictionary, "Dictionary"):
+                continue
+            if value == "" or key == "" or value == None or key == None:
+                filteredDictionaries.append(aDictionary)
+                filteredIndices.append(i)
+            else:
+                if isinstance(value, list):
+                    value.sort()
+                value = str(value)
+                value.replace("*",".+")
+                value = value.lower()
+                v = Dictionary.ValueAtKey(aDictionary, key)
+                if v == None:
+                    otherDictionaries.append(aDictionary)
+                    otherIndices.append(i)
+                    otherElements.append(elements[i])
+                else:
+                    v = str(v).lower()
+                    if searchType.lower() == "equal to":
+                        searchResult = (value == v)
+                    elif searchType.lower() == "contains":
+                        searchResult = (value in v)
+                    elif searchType.lower() == "starts with":
+                        searchResult = (value == v[0: len(value)])
+                    elif searchType.lower() == "ends with":
+                        searchResult = (value == v[len(v)-len(value):len(v)])
+                    elif searchType.lower() == "not equal to":
+                        searchResult = not (value == v)
+                    elif searchType.lower() == "does not contain":
+                        searchResult = not (value in v)
+                    else:
+                        searchResult = False
+                    if searchResult == True:
+                        filteredDictionaries.append(aDictionary)
+                        filteredIndices.append(i)
+                        filteredElements.append(elements[i])
+                    else:
+                        otherDictionaries.append(aDictionary)
+                        otherIndices.append(i)
+                        otherElements.append(elements[i])
+        return {"filteredDictionaries": filteredDictionaries, "otherDictionaries": otherDictionaries, "filteredIndices": filteredIndices, "otherIndices": otherIndices, "filteredElements": filteredElements, "otherElements": otherElements}
+
     @staticmethod
     def Keys(dictionary):
         """
@@ -579,7 +670,7 @@ class Dictionary():
             temp_value = attr.StringValue()
             topologies = None
             try:
-                topologies = Topology.ByJSONString(temp_value, progressBar=False)
+                topologies = Topology.ByJSONString(temp_value)
             except:
                 topologies = None
             if isinstance(topologies, list):
@@ -654,14 +745,21 @@ class Dictionary():
             if not silent == True:
                 print("Dictionary.ValueAtKey - Error: The input key parameter is not a valid str. Returning None.")
             return None
-        if isinstance(dictionary, dict):
-            attr = dictionary[key]
-        elif Topology.IsInstance(dictionary, "Dictionary"):
-            attr = dictionary.ValueAtKey(key)
-        else:
-            return None
-        return_value = Dictionary._ConvertAttribute(attr)
-        return return_value
+        if Topology.IsInstance(dictionary, "Dictionary"):
+            dic = Dictionary.PythonDictionary(dictionary)
+            return dic.get(key, None)
+        elif isinstance(dictionary, dict):
+            return dictionary.get(key, None)
+        return None
+        
+        # if isinstance(dictionary, dict):
+        #     attr = dictionary[key]
+        # elif Topology.IsInstance(dictionary, "Dictionary"):
+        #     attr = dictionary.ValueAtKey(key)
+        # else:
+        #     return None
+        # return_value = Dictionary._ConvertAttribute(attr)
+        # return return_value
         
     @staticmethod
     def Values(dictionary):
@@ -693,7 +791,7 @@ class Dictionary():
         for key in keys:
             try:
                 if isinstance(dictionary, dict):
-                    attr = dictionary[key]
+                    attr = dictionary.get(key, None)
                 elif Topology.IsInstance(dictionary, "Dictionary"):
                     attr = Dictionary.ValueAtKey(dictionary,key)
                 else:

topologicpy/Edge.py

@@ -1143,6 +1143,8 @@ class Edge():
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
 
+
+
         def calculate_normal(start_vertex, end_vertex):
             start_vertex = np.array([float(x) for x in start_vertex])
             end_vertex = np.array([float(x) for x in end_vertex])
@@ -1150,8 +1152,11 @@ class Edge():
             # Calculate the direction vector of the edge
             direction_vector = end_vertex - start_vertex
             
-            # Handle the horizontal edge case (no Z component)
-            if np.isclose(direction_vector[2], 0):
+            # Check if the edge is vertical (only Z component)
+            if np.isclose(direction_vector[0], 0) and np.isclose(direction_vector[1], 0):
+                # Choose an arbitrary perpendicular vector in the X-Y plane, e.g., [1, 0, 0]
+                normal_vector = np.array([1.0, 0.0, 0.0])
+            elif np.isclose(direction_vector[2], 0):
                 # The edge lies in the X-Y plane; compute a perpendicular in the X-Y plane
                 normal_vector = np.array([-direction_vector[1], direction_vector[0], 0.0])
             else:
@@ -1162,7 +1167,7 @@ class Edge():
             # Check if the normal vector is effectively zero before normalization
             if np.isclose(norm(normal_vector), 0):
                 return normal_vector
-            
+    
             # Normalize the normal vector
             normal_vector /= norm(normal_vector)  
             return normal_vector
@@ -1192,7 +1197,6 @@ class Edge():
 
         # Calculate the normal line
         normal_line_start, normal_line_end = calculate_normal_line(start_vertex, end_vertex)
-
         # Create the normal edge in Topologic
         sv = Vertex.ByCoordinates(list(normal_line_start))
         ev = Vertex.ByCoordinates(list(normal_line_end))

topologicpy/Face.py

@@ -2566,7 +2566,7 @@ class Face():
                 internal_face_number = len(face_internal_boundaries)
                 for i in range(internal_face_number):
                     face_internal_boundary = face_internal_boundaries[i]
-                    internal_vertices = Wire.Vertices(face_internal_boundary)
+                    internal_vertices = Topology.Vertices(face_internal_boundary)
                     internal_vertex_number = len(internal_vertices)
                     for j in range(internal_vertex_number):
                         gmsh.model.geo.addPoint(Vertex.X(internal_vertices[j]), Vertex.Y(internal_vertices[j], mantissa=mantissa), Vertex.Z(internal_vertices[j], mantissa=mantissa), meshSize, current_vertex_number+j+1)

topologicpy/Graph.py

@@ -3971,7 +3971,7 @@ class Graph:
                         d = Graph.TopologicalDistance(graph, va, vb, tolerance)
                     top_dist += d
                 if top_dist == 0:
-                    print("Topological Distance is Zero!!")
+                    print("Graph.ClosenessCentrality - Warning: Topological Distance is Zero.")
                     scores.append(0)
                 else:
                     scores.append(round((n-1)/top_dist, mantissa))
@@ -7847,20 +7847,24 @@ class Graph:
              sides = 8,
              angle = 0,
              vertexColor="black",
+             vertexColorKey=None,
              vertexSize=6,
+             vertexSizeKey=None,
              vertexLabelKey=None,
              vertexGroupKey=None,
              vertexGroups=[],
              showVertices=True,
-             showVertexLabels=False,
+             showVertexLabel=False,
              showVertexLegend=False,
              edgeColor="black",
+             edgeColorKey=None,
              edgeWidth=1,
+             edgeWidthKey=None,
              edgeLabelKey=None,
              edgeGroupKey=None,
              edgeGroups=[],
              showEdges=True,
-             showEdgeLabels=False,
+             showEdgeLabel=False,
              showEdgeLegend=False,
              colorScale='viridis',
              renderer=None,
@@ -7904,8 +7908,12 @@ class Graph:
             - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
             - A named CSS color.
             The default is "black".
+        vertexColorKey : str , optional
+            The dictionary key under which to find the vertex color. The default is None.
         vertexSize : float , optional
             The desired size of the vertices. The default is 1.1.
+        vertexSizeKey : str , optional
+            The dictionary key under which to find the vertex size. The default is None.
         vertexLabelKey : str , optional
             The dictionary key to use to display the vertex label. The default is None.
         vertexGroupKey : str , optional
@@ -7914,7 +7922,7 @@ class Graph:
             The list of vertex groups against which to index the color of the vertex. The default is [].
         showVertices : bool , optional
             If set to True the vertices will be drawn. Otherwise, they will not be drawn. The default is True.
-        showVertexLabels : bool , optional
+        showVertexLabel : bool , optional
             If set to True, the vertex labels are shown permenantely on screen. Otherwise, they are not. The default is False.
         showVertexLegend : bool , optional
             If set to True the vertex legend will be drawn. Otherwise, it will not be drawn. The default is False.
@@ -7926,8 +7934,12 @@ class Graph:
             - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
             - A named CSS color.
             The default is "black".
+        edgeColorKey : str , optional
+            The dictionary key under which to find the edge color. The default is None.
         edgeWidth : float , optional
             The desired thickness of the output edges. The default is 1.
+        edgeWidthKey : str , optional
+            The dictionary key under which to find the edge width. The default is None.
         edgeLabelKey : str , optional
             The dictionary key to use to display the edge label. The default is None.
         edgeGroupKey : str , optional
@@ -7936,7 +7948,7 @@ class Graph:
             The list of edge groups against which to index the color of the edge. The default is [].
         showEdges : bool , optional
             If set to True the edges will be drawn. Otherwise, they will not be drawn. The default is True.
-        showEdgeLabels : bool , optional
+        showEdgeLabel : bool , optional
             If set to True, the edge labels are shown permenantely on screen. Otherwise, they are not. The default is False.
         showEdgeLegend : bool , optional
             If set to True the edge legend will be drawn. Otherwise, it will not be drawn. The default is False.
@@ -7997,7 +8009,7 @@ class Graph:
             print("Graph.Show - Error: The input graph is not a valid graph. Returning None.")
             return None
         
-        data= Plotly.DataByGraph(graph, sagitta=sagitta, absolute=absolute, sides=sides,  angle=angle, vertexColor=vertexColor, vertexSize=vertexSize, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabels=showVertexLabels, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeWidth=edgeWidth, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabels=showEdgeLabels, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
+        data= Plotly.DataByGraph(graph, sagitta=sagitta, absolute=absolute, sides=sides,  angle=angle, vertexColor=vertexColor, vertexColorKey=vertexColorKey, vertexSize=vertexSize, vertexSizeKey=vertexSizeKey, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabel=showVertexLabel, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeColorKey=edgeColorKey, edgeWidth=edgeWidth, edgeWidthKey=edgeWidthKey, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabel=showEdgeLabel, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
         fig = Plotly.FigureByData(data, width=width, height=height, xAxis=xAxis, yAxis=yAxis, zAxis=zAxis, axisSize=axisSize, backgroundColor=backgroundColor,
                                   marginLeft=marginLeft, marginRight=marginRight, marginTop=marginTop, marginBottom=marginBottom, tolerance=tolerance)
         Plotly.Show(fig, renderer=renderer, camera=camera, center=center, up=up, projection=projection)

topologicpy/Helper.py

@@ -95,6 +95,117 @@ class Helper:
 
         return closest_index
 
+    @staticmethod
+    def ClusterByKeys(elements, dictionaries, *keys, silent=False):
+        """
+            Clusters the input list of elements and dictionaries based on the input key or keys.
+
+            Parameters
+            ----------
+            elements : list
+                The input list of elements to be clustered.
+            dictionaries : list[Topology.Dictionary]
+                The input list of dictionaries to be consulted for clustering. This is assumed to be in the same order as the list of elements.
+            keys : str or list or comma-separated str input parameters
+                The key or keys in the topology's dictionary to use for clustering.
+            silent : bool , optional
+                If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+
+            Returns
+            -------
+            dict
+                A dictionary containing the elements and the dictionaries, but clustered. The dictionary has two keys:
+                "elements": list
+                    A nested list of elements where each item is a list of elements with the same key values.
+                "dictionaries": list
+                    A nested list of dictionaries where each item is a list of dictionaries with the same key values.
+            """
+        
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
+        import inspect
+
+        keys_list = list(keys)
+        keys_list = Helper.Flatten(keys_list)
+        keys_list = [x for x in keys_list if isinstance(x, str)]
+
+        if len(keys_list) == 0:
+            if not silent:
+                print("Helper.ClusterByKeys - Error: The input keys parameter is an empty list. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
+            return None
+        
+        if len(keys_list) == 0:
+            if not silent:
+                print("Helper.ClusterByKeys - Error: The input keys parameter does not contain any valid strings. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
+            return None
+        if not (len(elements) == len(dictionaries)):
+            if not silent:
+                print("Helper.ClusterByKeys - Error: The input elements parameter does not have the same length as the input dictionaries parameter. Returning None.")
+            return None
+        
+        elements_clusters = []
+        dict_clusters = []
+        values = []
+        new_dictionaries = []
+        for i, d in enumerate(dictionaries):
+            element = elements[i]
+
+            d_keys = Dictionary.Keys(d)
+            if len(d_keys) > 0:
+                values_list = []
+                for key in keys_list:
+                    v = Dictionary.ValueAtKey(d, key)
+                    if not v == None:
+                        values_list.append(v)
+                values_list = str(values_list)
+                d = Dictionary.SetValueAtKey(d, "_clustering_key_", values_list)
+                new_dictionaries.append(d)
+                values.append(values_list)
+        
+        values = list(set(values))
+        remaining_dictionaries = [x for x in new_dictionaries]
+        remaining_elements = [x for x in elements]
+        remaining_indices = [i for i, x in enumerate(elements)]
+
+        if len(values) == 0:
+            return {"elements": [elements], "dictionaries": [dictionaries]}
+        for value in values:
+            if len(remaining_dictionaries) == 0:
+                break
+            dict = Dictionary.Filter(remaining_elements, remaining_dictionaries, searchType="equal to", key="_clustering_key_", value=value)
+            filtered_indices = dict['filteredIndices']
+            final_dictionaries = []
+            final_elements = []
+            if len(filtered_indices) > 0:
+                for filtered_index in filtered_indices:
+                    filtered_dictionary = remaining_dictionaries[filtered_index]
+                    filtered_dictionary = Dictionary.RemoveKey(filtered_dictionary, "_clustering_key_")
+                    final_dictionaries.append(filtered_dictionary)
+                    filtered_element = remaining_elements[filtered_index]
+                    final_elements.append(filtered_element)
+                dict_clusters.append(final_dictionaries)
+                elements_clusters.append(final_elements)
+            remaining_dictionaries = dict['otherDictionaries']
+            remaining_elements = dict['otherElements']
+            remaining_indices = dict['otherIndices']
+        if len(remaining_elements) > 0:
+            temp_dict_cluster = []
+            temp_element_cluster = []
+            for remaining_index in remaining_indices:
+                temp_element_cluster.append(remaining_elements[remaining_index])
+                temp_dict_cluster.append(remaining_dictionaries[remaining_index])
+            if len(temp_element_cluster) > 0:
+                dict_clusters.append(temp_dict_cluster)
+                elements_clusters.append(temp_element_cluster)
+        return {"elements": elements_clusters, "dictionaries": dict_clusters}
+
     @staticmethod
     def Flatten(listA):
         """