topologicpy 0.8.39__py3-none-any.whl → 0.8.41__py3-none-any.whl

topologicpy/Color.py

@@ -55,7 +55,80 @@ class Color:
 
         return return_hex.upper()
     
-    
+    @staticmethod
+    def AverageHex(*colors, silent: bool = False):
+        """
+        Averages the input list of hex colors.
+
+        Parameters
+        ----------
+        colors : *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'.
+        """
+        from topologicpy.Helper import Helper
+        import inspect
+
+        def avg(hex1, hex2):
+            # Remove leading "#" if present
+            hex1 = hex1.lstrip('#')
+            hex2 = hex2.lstrip('#')
+
+            # Convert to RGB components
+            r1, g1, b1 = int(hex1[0:2], 16), int(hex1[2:4], 16), int(hex1[4:6], 16)
+            r2, g2, b2 = int(hex2[0:2], 16), int(hex2[2:4], 16), int(hex2[4:6], 16)
+
+            # Compute average for each channel
+            r_avg = (r1 + r2) // 2
+            g_avg = (g1 + g2) // 2
+            b_avg = (b1 + b2) // 2
+
+            # Return as hex string
+            return f"#{r_avg:02X}{g_avg:02X}{b_avg:02X}"
+        
+        if len(colors) == 0:
+            if not silent:
+                print("Color.AverageColors - Error: The input colors 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(colors) == 1:
+            colorList = colors[0]
+            if isinstance(colorList, list):
+                if len(colorList) == 0:
+                    if not silent:
+                        print("Color.AverageHex - Error: The input colors parameter is an empty list. Returning None.")
+                        curframe = inspect.currentframe()
+                        calframe = inspect.getouterframes(curframe, 2)
+                        print('caller name:', calframe[1][3])
+                    return None
+            else:
+                if not silent:
+                    print("Color.AverageHex - Warning: The input colors parameter contains only one color. Returning the same topology.")
+                    curframe = inspect.currentframe()
+                    calframe = inspect.getouterframes(curframe, 2)
+                    print('caller name:', calframe[1][3])
+                return colorList
+        else:
+            colorList = Helper.Flatten(list(colors))
+            colorList = [x for x in colorList if isinstance(x, str)]
+        if len(colorList) == 0:
+            if not silent:
+                print("Color.AverageHex - Error: The input parameters do not contain any valid colors. Returning None.")
+                curframe = inspect.currentframe()
+                calframe = inspect.getouterframes(curframe, 2)
+                print('caller name:', calframe[1][3])
+            return None
+        final_color = Color.AnyToHex(colorList[0])
+        for clr in colorList[1:]:
+            final_color = avg(final_color, Color.AnyToHex(clr))
+        return final_color
+
     @staticmethod
     def ByCSSNamedColor(color, alpha: float = None):
         """

topologicpy/Graph.py

@@ -7751,6 +7751,34 @@ class Graph:
                 edge = Topology.SetDictionary(edge, d)
         return graph
 
+    @staticmethod
+    def IsEmpty(graph, silent: bool = False):
+        """
+        Tests if the input graph is empty (Has no vertices).
+        
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. The default is False.
+        
+        Returns
+        -------
+        bool
+            True if the two input graphs are isomorphic. False otherwise
+
+        """
+        
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Graph.IsEmpty - Error: The input graph parameter is not a valid graph. Returning None.")
+            return None
+        
+        return (len(Graph.Vertices(graph)) == 0)
+    
     @staticmethod
     def IsIsomorphic(graphA, graphB, maxIterations=10, silent=False):
         """
@@ -9192,6 +9220,142 @@ class Graph:
             return None
         return graph.GetGUID()
 
+    @staticmethod
+    def HasseDiagram(topology, types=["vertex", "edge", "wire", "face", "shell", "cell", "cellComplex"], topDown: bool = False, minDistance: float=0.1, vertexLabelKey: str="label", vertexTypeKey: str="type", vertexColorKey: str="color", colorScale: str="viridis", storeBREP: bool = False, tolerance: float=0.0001, silent: bool=False):
+        """
+            Constructs a Hasse diagram from the input topology as a directed graph. See: https://en.wikipedia.org/wiki/Hasse_diagram
+            Vertices represent topologies (vertices, edges, wires, faces, shells, cells, cellComplexes).
+            Edges represent inclusion (e.g. vertex ⊂ edge, edge ⊂ wire).
+
+            Parameters
+            ----------
+            topology : topologic_core.Topology
+                The input topology
+            types : optional, list
+                The list of topology types that you wish to encode in the Hasse diagram.
+                This list must be ordered according to topologic_core's class hierarchy.
+                If you are not interested in representing some topology types. These can be omitted.
+                The default is:
+                ["vertex", "edge", "wire", "face", "shell", "cell", "cellComplex"].
+            topDown : bool , optional
+                If set to True, the graph edges are directed from topologies to their subtopologies.
+                Otherwise, they are directed from topologies to their supertopologies. The default is False. 
+            minDistance : float , optional
+                The desired minimum distance between the vertices of the graph. The default is 0.1.
+            vertexLabelKey: str , optional
+                The desired vertex dictionary key under which to store a unique label (of the form Type_Index). The default is "label".
+            vertexTypeKey: str , optional
+                The desired vertex dictionary key under which to store the topology type (e.g. "vertex", "edge", "wire"). The default is "type".
+            vertexColorKey: str , optional
+                The desired vertex dictionary key under which to store the topology color. The default is "color".
+            colorScale : str , optional
+                The desired type of plotly color scales to use (e.g. "viridis", "plasma"). The default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
+                In addition to these, three color-blind friendly scales are included. These are "protanopia", "deuteranopia", and "tritanopia" for red, green, and blue colorblindness respectively.
+            storeBREP : bool , optional
+                If set to True, store the BRep of the topology in its representative vertex. The default is False.
+            tolerance : float
+                The desired tolerance. The default is 0.0001.
+            silent : bool , optional
+                    If set to True, error and warning messages are suppressed. The default is False.
+
+            Returns
+            -------
+            topologic_core.Graph
+                The created Hesse diagram graph.
+
+            """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Color import Color
+        from topologicpy.Topology import Topology
+
+        def label(topo, index):
+            cls = Topology.TypeAsString(topo)
+            return f"{cls}_{index}"
+        
+        def collect_topologies(topology, topo_types):
+            """
+            Returns a dict of all sub-topologies by dimension.
+            """
+            topo_by_type = {}
+            for sub_type in topo_types:
+                topo_by_type[sub_type] = Topology.SubTopologies(topology, subTopologyType=sub_type)
+            return topo_by_type
+        
+        if not Topology.IsInstance(topology, "topology"):
+            if not silent:
+                print("Graph.HasseDiagram - Error: The input topology parameter is not a valid topology. Returning None.")
+            return None
+        if minDistance <= tolerance:
+            if not silent:
+                print("Graph.HasseDiagram - Error: The input minDistance parameter cannot be less than the input tolerance parameter. Returning None.")
+            return None
+        types = [t.lower() for t in types]
+        for type in types:
+            if type not in ["vertex", "edge", "wire", "face", "shell", "cell", "cellcomplex"]:
+                if not silent:
+                    print("Graph.HasseDiagram - Error: Unknown type found in the types input parameter. Returning None.")
+                return None
+
+        topology_type = Topology.TypeAsString(topology).lower()
+        try:
+            sub_types = types[:types.index(topology_type)]
+        except:
+            sub_types = types
+        topo_by_type = collect_topologies(topology, sub_types)
+        all_topos = []
+        topo_ids = {}
+        index = 0
+
+        # Flatten and assign unique labels
+        for sub_type in sub_types:
+            color = Color.AnyToHex(Color.ByValueInRange(float(types.index(sub_type)), minValue=0, maxValue=6, colorScale=colorScale))
+            lbl_index = 1
+            for t in topo_by_type[sub_type]:
+                lbl = label(t, lbl_index)
+                d = Topology.Dictionary(t)
+                d = Dictionary.SetValuesAtKeys(d, [vertexLabelKey, vertexTypeKey, vertexColorKey], [lbl, sub_type, color])
+                t = Topology.SetDictionary(t, d)
+                all_topos.append(t)
+                topo_ids[lbl] = index
+                index += 1
+                lbl_index += 1
+
+        # Create graph vertices
+        graph_vertices = [Topology.Centroid(_) for _ in all_topos]
+
+        # Add dictionaries to each vertex
+        for i, t in enumerate(all_topos):
+            d = Topology.Dictionary(t)
+            if storeBREP == True:
+                d = Dictionary.SetValueAtKey(d,"brep", Topology.BREPString(t))
+            graph_vertices[i] = Topology.SetDictionary(graph_vertices[i], d)
+        
+        graph_vertices = Vertex.Separate(graph_vertices, minDistance= minDistance, tolerance=tolerance)
+        # Build edges of Hasse diagram
+        graph_edges = []
+        for parent_type in sub_types[1:]:
+            for parent in topo_by_type[parent_type]:
+                parent_label = Dictionary.ValueAtKey(Topology.Dictionary(parent), vertexLabelKey)
+                children = Topology.SubTopologies(parent, subTopologyType=types[types.index(parent_type) - 1])
+                for child in children:
+                    child_label = Dictionary.ValueAtKey(Topology.Dictionary(child), vertexLabelKey)
+                    child_id = topo_ids.get(child_label)
+                    parent_id = topo_ids.get(parent_label)
+                    if child_id is not None and parent_id is not None:
+                        if topDown:
+                            sv = graph_vertices[parent_id]
+                            ev = graph_vertices[child_id]
+                        else:
+                            sv = graph_vertices[child_id]
+                            ev = graph_vertices[parent_id]
+                        graph_edges.append(Edge.ByVertices(sv, ev, tolerance=tolerance, silent=silent))
+
+        return_graph = Graph.ByVerticesEdges(graph_vertices, graph_edges)
+        return_graph = Graph.SetDictionary(return_graph, Topology.Dictionary(topology))
+        return return_graph
+
     @staticmethod
     def IncomingEdges(graph, vertex, directed: bool = False, tolerance: float = 0.0001) -> list:
         """
@@ -12914,38 +13078,49 @@ class Graph:
         return round(numerator / denominator, mantissa) if denominator != 0 else 0.0
 
     @staticmethod
-    def _vertex_is_same(v1, v2, key=None):
+    def _vertex_is_same(v1, v2, keys=None, tolerance=0.0001):
+        from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
+
+        if keys == None or keys == [] or keys == "":
+            return Vertex.Distance(v1, v2) <= tolerance
+        
+        if isinstance(keys, str):
+            if "loc" in keys.lower() or "coord" in keys.lower() or "xyz" in keys.lower():
+                return Vertex.Distance(v1, v2) <= tolerance
+        if not isinstance(keys, list):
+            keys = [keys]
+        
         d1 = Topology.Dictionary(v1)
         d2 = Topology.Dictionary(v2)
-        a = Dictionary.ValueAtKey(d1, key, "0")
-        b = Dictionary.ValueAtKey(d2, key, "1")
+        a = [Dictionary.ValueAtKey(d1, k, "0") for k in keys]
+        b = [Dictionary.ValueAtKey(d2, k, "1") for k in keys]
         return a == b
 
     @staticmethod
-    def _vertex_in_list(vertex, vertex_list, key=None):
+    def _vertex_in_list(vertex, vertex_list, keys=None, tolerance=0.0001):
         for i, v1 in enumerate(vertex_list):
-            if Graph._vertex_is_same(vertex, v1, key=key):
+            if Graph._vertex_is_same(vertex, v1, keys=keys, tolerance=tolerance):
                 return i+1
         return False
 
     @staticmethod
-    def _edge_in_list(edge, edge_list, vertices_a, vertices_b, key=None):
+    def _edge_in_list(edge, edge_list, vertices_a, vertices_b, keys=None, tolerance=0.0001):
         sv1 = vertices_a[edge[0]]
         ev1 = vertices_a[edge[1]]
         for i, e in enumerate(edge_list):
             sv2 = vertices_b[e[0]]
             ev2 = vertices_b[e[1]]
-            if (Graph._vertex_is_same(sv1, sv2, key=key) and Graph._vertex_is_same(ev1, ev2, key=key)) or \
-                (Graph._vertex_is_same(sv1, ev2, key=key) and Graph._vertex_is_same(ev1, sv2, key=key)):
+            if (Graph._vertex_is_same(sv1, sv2, keys=keys, tolerance=tolerance) and Graph._vertex_is_same(ev1, ev2, keys=keys, tolerance=tolerance)) or \
+                (Graph._vertex_is_same(sv1, ev2, keys=keys, tolerance=tolerance) and Graph._vertex_is_same(ev1, sv2, keys=keys, tolerance=tolerance)):
                 return i+1
         return False
 
     @staticmethod
-    def Union(graphA, graphB, vertexKey: str, silent: bool = False):
+    def Union(graphA, graphB, vertexKeys=None, useCentroid: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
-        Union the two input graphs based on an input vertex key. See https://en.wikipedia.org/wiki/Boolean_operation.
+        Union the two input graphs based on the input vertex keys. See https://en.wikipedia.org/wiki/Boolean_operation.
 
         Parameters
         ----------
@@ -12953,11 +13128,18 @@ class Graph:
             The first input graph.
         graphB : topologic_core.Graph
             The second input graph.
-        vertexKey : str
-            The vertex dictionary key to use to determine if two vertices are the same. 
+        vertexKeys : list or str , optional
+            The vertex dictionary key (str) or keys (list of str) to use to determine if two vertices are the same.
+            If the vertexKeys are set to None or "loc" or "coord" or "xyz" (case insensitive), the distance between the
+            vertices (within the tolerance) will be used to determine sameness. The default is None.
+        useCentroid : bool , optional
+            If set to True, the coordinates of identical vertices from each graph are averaged to located the new merged vertex of the resulting graph.
+            Otherwise, the coordinates of the vertex of the first input graph are used. The default is False.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
         silent : bool , optional
             If set to True, error and warning messages are suppressed. The default is False.
-
+        
         Returns
         -------
         topologic_core.Graph
@@ -12968,6 +13150,7 @@ class Graph:
         from topologicpy.Edge import Edge
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
+        from topologicpy.Cluster import Cluster
 
         if not Topology.IsInstance(graphA, "graph"):
             if not silent:
@@ -12977,10 +13160,6 @@ class Graph:
             if not silent:
                 print("Graph.Union - Error: The graphB input parameter is not a valid graph. Returning None.")
             return None
-        if not isinstance(vertexKey, str):
-            if not silent:
-                print("Graph.Union - Error: The vertexKey input parameter is not a valid string. Returning None.")
-            return None
         vertices_a = Graph.Vertices(graphA)
         vertices_a_new = []
         for v in vertices_a:
@@ -13008,11 +13187,16 @@ class Graph:
 
         def _add_vertex(v):
             for i, uv in enumerate(union_vertices):
-                if Graph._vertex_is_same(v, uv, key=vertexKey):
+                if Graph._vertex_is_same(v, uv, keys=vertexKeys):
                     d_a = Topology.Dictionary(v)
                     d_b = Topology.Dictionary(uv)
                     d_c = Dictionary.ByMergedDictionaries(d_a, d_b)
-                    uv = Topology.SetDictionary(uv, d_c)
+                    if useCentroid:
+                        c = Topology.Centroid(Cluster.ByTopologies([v, uv]))
+                    else:
+                        c = uv
+                    c = Topology.SetDictionary(c, d_c)
+                    union_vertices[i] = c
                     return i
             union_vertices.append(v)
             return len(union_vertices) - 1
@@ -13029,8 +13213,8 @@ class Graph:
             for k, e in enumerate(union_edges):
                 svi = Edge.StartVertex(e)
                 evi = Edge.EndVertex(e)
-                if (Graph._vertex_is_same(svi, vi, key=vertexKey) and Graph._vertex_is_same(evi, vj, key=vertexKey)) or \
-                (Graph._vertex_is_same(svi, vj, key=vertexKey) and Graph._vertex_is_same(evi, vi, key=vertexKey)):
+                if (Graph._vertex_is_same(svi, vi, keys=vertexKeys, tolerance=tolerance) and Graph._vertex_is_same(evi, vj, keys=vertexKeys, tolerance=tolerance)) or \
+                (Graph._vertex_is_same(svi, vj, keys=vertexKeys, tolerance=tolerance) and Graph._vertex_is_same(evi, vi, keys=vertexKeys, tolerance=tolerance)):
                     # Merge dictionaries
                     d_a = Topology.Dictionary(e)
                     d_c = Dictionary.ByMergedDictionaries([d_a, dictionary], silent=True)
@@ -13047,20 +13231,145 @@ class Graph:
         for idx, e in enumerate(edges_a):
             i = index_map_a[e[0]]
             j = index_map_a[e[1]]
-            _add_edge(i, j, Dictionary.ByPythonDictionary(edges_a_dicts[idx]))
+            if not i == j:
+                _add_edge(i, j, Dictionary.ByPythonDictionary(edges_a_dicts[idx]))
 
         # Add edges from B, merging duplicates
         for idx, e in enumerate(edges_b):
             i = index_map_b[e[0]]
             j = index_map_b[e[1]]
-            _add_edge(i, j, Dictionary.ByPythonDictionary(edges_b_dicts[idx]))
+            if not i == j:
+                _add_edge(i, j, Dictionary.ByPythonDictionary(edges_b_dicts[idx]))
 
         return Graph.ByVerticesEdges(union_vertices, union_edges)
+    
+    @staticmethod
+    def Impose(graphA, graphB, vertexKeys=None, useCentroid: bool = False, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Imposes the second input graph on the first input graph based on the input vertex keys. See https://en.wikipedia.org/wiki/Boolean_operation.
+
+        Parameters
+        ----------
+        graphA : topologic_core.Graph
+            The first input graph.
+        graphB : topologic_core.Graph
+            The second input graph.
+        vertexKeys : list or str , optional
+            The vertex dictionary key (str) or keys (list of str) to use to determine if two vertices are the same.
+            If the vertexKeys are set to None or "loc" or "coord" or "xyz" (case insensitive), the distance between the
+            vertices (within the tolerance) will be used to determine sameness. The default is None.
+        useCentroid : bool , optional
+            If set to True, the coordinates of identical vertices from each graph are averaged to located the new merged vertex of the resulting graph.
+            Otherwise, the coordinates of the vertex of the second input graph are used. The default is False.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. The default is False.
+        
+
+        Returns
+        -------
+        topologic_core.Graph
+            the resultant graph. Vertex and edge dictionaries are merged.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Cluster import Cluster
+
+        if not Topology.IsInstance(graphA, "graph"):
+            if not silent:
+                print("Graph.Impose - Error: The graphA input parameter is not a valid graph. Returning None.")
+            return None
+        if not Topology.IsInstance(graphB, "graph"):
+            if not silent:
+                print("Graph.Impose - Error: The graphB input parameter is not a valid graph. Returning None.")
+            return None
+        vertices_a = Graph.Vertices(graphA)
+        vertices_a_new = []
+        for v in vertices_a:
+            d = Topology.Dictionary(v)
+            v_new = Vertex.ByCoordinates(Vertex.Coordinates(v))
+            v_new = Topology.SetDictionary(v_new, d)
+            vertices_a_new.append(v_new)
+        vertices_a = vertices_a_new
+        vertices_b = Graph.Vertices(graphB)
+        vertices_b_new = []
+        for v in vertices_b:
+            d = Topology.Dictionary(v)
+            v_new = Vertex.ByCoordinates(Vertex.Coordinates(v))
+            v_new = Topology.SetDictionary(v_new, d)
+            vertices_b_new.append(v_new)
+        vertices_b = vertices_b_new
+        mesh_data_a = Graph.MeshData(graphA)
+        mesh_data_b = Graph.MeshData(graphB)
+        edges_a = mesh_data_a['edges']
+        edges_b = mesh_data_b['edges']
+        edges_a_dicts = mesh_data_a['edgeDictionaries']
+        edges_b_dicts = mesh_data_b['edgeDictionaries']
+
+        union_vertices = []
+
+        def _add_vertex(v):
+            for i, uv in enumerate(union_vertices):
+                if Graph._vertex_is_same(v, uv, keys=vertexKeys):
+                    d_c = Topology.Dictionary(v) # Dictionaries of graphB are imposed.
+                    if useCentroid:
+                        c = Topology.Centroid(Cluster.ByTopologies([v, uv]))
+                    else:
+                        c = v
+                    c = Topology.SetDictionary(c, d_c)
+                    union_vertices[i] = c
+                    return i
+            union_vertices.append(v)
+            return len(union_vertices) - 1
+
+        # Map original vertices to indices in union list
+        index_map_a = [_add_vertex(v) for v in vertices_a]
+        index_map_b = [_add_vertex(v) for v in vertices_b]
+
+        union_edges = []
+
+        def _add_edge(i, j, dictionary):
+            vi = union_vertices[i]
+            vj = union_vertices[j]
+            for k, e in enumerate(union_edges):
+                svi = Edge.StartVertex(e)
+                evi = Edge.EndVertex(e)
+                if (Graph._vertex_is_same(svi, vi, keys=vertexKeys, tolerance=tolerance) and Graph._vertex_is_same(evi, vj, keys=vertexKeys, tolerance=tolerance)) or \
+                (Graph._vertex_is_same(svi, vj, keys=vertexKeys, tolerance=tolerance) and Graph._vertex_is_same(evi, vi, keys=vertexKeys, tolerance=tolerance)):
+                    # Impose edge dictionary from graphB
+                    new_edge = Edge.ByVertices(vi, vj)
+                    new_edge = Topology.SetDictionary(new_edge, dictionary, silent=True)
+                    union_edges[k] = new_edge
+                    return
+            # If not found, add new edge
+            edge = Edge.ByVertices(vi, vj)
+            edge = Topology.SetDictionary(edge, dictionary)
+            union_edges.append(edge)
+
+        # Add edges from A
+        for idx, e in enumerate(edges_a):
+            i = index_map_a[e[0]]
+            j = index_map_a[e[1]]
+            if not i == j:
+                _add_edge(i, j, Dictionary.ByPythonDictionary(edges_a_dicts[idx]))
+
+        # Add edges from B, merging duplicates
+        for idx, e in enumerate(edges_b):
+            i = index_map_b[e[0]]
+            j = index_map_b[e[1]]
+            if not i == j:
+                _add_edge(i, j, Dictionary.ByPythonDictionary(edges_b_dicts[idx]))
 
+        return Graph.ByVerticesEdges(union_vertices, union_edges)
+    
     @staticmethod
-    def Intersect(graphA, graphB, vertexKey: str, silent: bool = False):
+    def Imprint(graphA, graphB, vertexKeys, useCentroid: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
-        Intersect the two input graphs based on an input vertex key. See https://en.wikipedia.org/wiki/Boolean_operation.
+        Imprints the second input graph on the first input graph based on the input vertex keys. See https://en.wikipedia.org/wiki/Boolean_operation.
 
         Parameters
         ----------
@@ -13068,8 +13377,15 @@ class Graph:
             The first input graph.
         graphB : topologic_core.Graph
             The second input graph.
-        vertexKey : str
-            The vertex dictionary key to use to determine if two vertices are the same. 
+        vertexKeys : list or str , optional
+            The vertex dictionary key (str) or keys (list of str) to use to determine if two vertices are the same.
+            If the vertexKeys are set to None or "loc" or "coord" or "xyz" (case insensitive), the distance between the
+            vertices (within the tolerance) will be used to determine sameness. The default is None.
+        useCentroid : bool , optional
+            If set to True, the coordinates of identical vertices from each graph are averaged to located the new merged vertex of the resulting graph.
+            Otherwise, the coordinates of the vertex of the first input graph are used. The default is False.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
         silent : bool , optional
             If set to True, error and warning messages are suppressed. The default is False.
 
@@ -13081,20 +13397,126 @@ class Graph:
         """
         from topologicpy.Vertex import Vertex
         from topologicpy.Edge import Edge
+        from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         from topologicpy.Dictionary import Dictionary
 
         if not Topology.IsInstance(graphA, "graph"):
             if not silent:
-                print("Graph.Intersect - Error: The graphA input parameter is not a valid graph. Returning None.")
+                print("Graph.Imprint - Error: The graphA input parameter is not a valid graph. Returning None.")
             return None
         if not Topology.IsInstance(graphB, "graph"):
             if not silent:
-                print("Graph.Intersect - Error: The graphB input parameter is not a valid graph. Returning None.")
+                print("Graph.Imprint - Error: The graphB input parameter is not a valid graph. Returning None.")
+            return None
+
+        vertices_a = Graph.Vertices(graphA)
+        vertices_a_new = []
+        for v in vertices_a:
+            d = Topology.Dictionary(v)
+            v_new = Vertex.ByCoordinates(Vertex.Coordinates(v))
+            v_new = Topology.SetDictionary(v_new, d)
+            vertices_a_new.append(v_new)
+        vertices_a = vertices_a_new
+        vertices_b = Graph.Vertices(graphB)
+        vertices_b_new = []
+        for v in vertices_b:
+            d = Topology.Dictionary(v)
+            v_new = Vertex.ByCoordinates(Vertex.Coordinates(v))
+            v_new = Topology.SetDictionary(v_new, d)
+            vertices_b_new.append(v_new)
+        vertices_b = vertices_b_new
+        mesh_data_a = Graph.MeshData(graphA)
+        mesh_data_b = Graph.MeshData(graphB)
+        topo_edges_a = Graph.Edges(graphA)
+        edges_a = mesh_data_a['edges']
+        edges_b = mesh_data_b['edges']
+        edges_b_dicts = mesh_data_b['edgeDictionaries']
+
+        final_vertices = []
+        vertex_map = {}
+        for i, a in enumerate(vertices_a):
+            j = Graph._vertex_in_list(a, vertices_b, keys=vertexKeys, tolerance=tolerance)
+            if j:
+                b = vertices_b[j-1]
+                if useCentroid:
+                    c = Topology.Centroid(Cluster.ByTopologies([a, b]))
+                else:
+                    c = a
+                d_c = Topology.Dictionary(b)
+                c = Topology.SetDictionary(c, d_c, silent=True)
+                vertex_map[i] = c
+                final_vertices.append(c)
+            else:
+                final_vertices.append(a)
+        if len(final_vertices) < 1:
+            if not silent:
+                print("Graph.Imprint - Warning: graphA and graphB do not intersect. Returning None.")
+            return None
+
+        final_edges = []
+
+        for i, e in enumerate(edges_a):
+            j = Graph._edge_in_list(e, edges_b, vertices_a, vertices_b, keys=vertexKeys, tolerance=tolerance)
+            if j:
+                # Merge the dictionaries
+                d_c = Dictionary.ByPythonDictionary(edges_b_dicts[j-1]) # We added 1 to j to avoid 0 which can be interpreted as False.
+                # Create the edge
+                #final_edge = Edge.ByVertices(vertices_a[e[0]], vertices_a[e[1]])
+                sv = vertex_map[e[0]]
+                ev = vertex_map[e[1]]
+                final_edge = Edge.ByVertices(sv, ev)
+                # Set the edge's dictionary
+                final_edge = Topology.SetDictionary(final_edge, d_c, silent=True)
+                # Add the final edge to the list
+                final_edges.append(final_edge)
+            else:
+                final_edges.append(topo_edges_a[i])
+
+        return Graph.ByVerticesEdges(final_vertices, final_edges)
+
+    @staticmethod
+    def Intersect(graphA, graphB, vertexKeys, vertexColorKey="color", useCentroid: bool = False, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Intersect the two input graphs based on the input vertex keys. See https://en.wikipedia.org/wiki/Boolean_operation.
+
+        Parameters
+        ----------
+        graphA : topologic_core.Graph
+            The first input graph.
+        graphB : topologic_core.Graph
+            The second input graph.
+        vertexKeys : list or str , optional
+            The vertex dictionary key (str) or keys (list of str) to use to determine if two vertices are the same.
+            If the vertexKeys are set to None or "loc" or "coord" or "xyz" (case insensitive), the distance between the
+            vertices (within the tolerance) will be used to determine sameness. The default is None.
+        useCentroid : bool , optional
+            If set to True, the coordinates of identical vertices from each graph are averaged to located the new merged vertex of the resulting graph.
+            Otherwise, the coordinates of the vertex of the first input graph are used. The default is False.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. The default is False.
+
+        Returns
+        -------
+        topologic_core.Graph
+            the resultant graph. Vertex and edge dictionaries are merged.
+
+        """
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Cluster import Cluster
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        if not Topology.IsInstance(graphA, "graph"):
+            if not silent:
+                print("Graph.Intersect - Error: The graphA input parameter is not a valid graph. Returning None.")
             return None
-        if not isinstance(vertexKey, str):
+        if not Topology.IsInstance(graphB, "graph"):
             if not silent:
-                print("Graph.Intersect - Error: The vertexKey input parameter is not a valid string. Returning None.")
+                print("Graph.Intersect - Error: The graphB input parameter is not a valid graph. Returning None.")
             return None
 
         vertices_a = Graph.Vertices(graphA)
@@ -13121,27 +13543,40 @@ class Graph:
         edges_b_dicts = mesh_data_b['edgeDictionaries']
 
         common_vertices = []
-        for i, v in enumerate(vertices_a):
-            j = Graph._vertex_in_list(v, vertices_b, key=vertexKey)
+        vertex_map = {}
+        for i, a in enumerate(vertices_a):
+            j = Graph._vertex_in_list(a, vertices_b, keys=vertexKeys, tolerance=tolerance)
             if j:
-                d_a = Topology.Dictionary(v)
-                d_b = Topology.Dictionary(vertices_b[j-1])
+                b = vertices_b[j-1]
+                if useCentroid:
+                    c = Topology.Centroid(Cluster.ByTopologies([a, b]))
+                else:
+                    c = a
+                d_a = Topology.Dictionary(a)
+                d_b = Topology.Dictionary(b)
                 d_c = Dictionary.ByMergedDictionaries([d_a, d_b], silent=True)
-                v = Topology.SetDictionary(v, d_c, silent=True)
-                common_vertices.append(v)
+                c = Topology.SetDictionary(c, d_c, silent=True)
+                vertex_map[i] = c
+                common_vertices.append(c)
+        if len(common_vertices) < 1:
+            if not silent:
+                print("Graph.Intersect - Warning: graphA and graphB do not intersect. Returning None.")
+            return None
+
         common_edges = []
 
         for i, e in enumerate(edges_a):
-            j = Graph._edge_in_list(e, edges_b, vertices_a, vertices_b, key=vertexKey)
+            j = Graph._edge_in_list(e, edges_b, vertices_a, vertices_b, keys=vertexKeys, tolerance=tolerance)
             if j:
                 # Merge the dictionaries
                 d_a = Dictionary.ByPythonDictionary(edges_a_dicts[i])
                 d_b = Dictionary.ByPythonDictionary(edges_b_dicts[j-1]) # We added 1 to j to avoid 0 which can be interpreted as False.
                 d_c = Dictionary.ByMergedDictionaries([d_a, d_b], silent=True)
-                print("Intersect - d_c:", d_c)
-                print(Dictionary.Keys(d_c), Dictionary.Values(d_c))
                 # Create the edge
-                final_edge = Edge.ByVertices(vertices_a[e[0]], vertices_a[e[1]])
+                #final_edge = Edge.ByVertices(vertices_a[e[0]], vertices_a[e[1]])
+                sv = vertex_map[e[0]]
+                ev = vertex_map[e[1]]
+                final_edge = Edge.ByVertices(sv, ev)
                 # Set the edge's dictionary
                 final_edge = Topology.SetDictionary(final_edge, d_c, silent=True)
                 # Add the final edge to the list
@@ -13150,9 +13585,9 @@ class Graph:
         return Graph.ByVerticesEdges(common_vertices, common_edges)
 
     @staticmethod
-    def Difference(graphA, graphB, vertexKey: str, silent: bool = False):
+    def Difference(graphA, graphB, vertexKeys, useCentroid: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
-        Intersect the two input graphs based on an input vertex key. See https://en.wikipedia.org/wiki/Boolean_operation.
+        Intersect the two input graphs based on the input vertex keys. See https://en.wikipedia.org/wiki/Boolean_operation.
 
         Parameters
         ----------
@@ -13160,8 +13595,14 @@ class Graph:
             The first input graph.
         graphB : topologic_core.Graph
             The second input graph.
-        vertexKey : str
-            The vertex dictionary key to use to determine if two vertices are the same. 
+        vertexKeys : list or str , optional
+            The vertex dictionary key (str) or keys (list of str) to use to determine if two vertices are the same.
+            If the vertexKeys are set to None or "loc" or "coord" or "xyz" (case insensitive), the distance between the
+            vertices (within the tolerance) will be used to determine sameness. The default is None.
+        useCentroid : bool , optional
+            This is not used here, but included for API consistency for boolean operations.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
         silent : bool , optional
             If set to True, error and warning messages are suppressed. The default is False.
 
@@ -13184,25 +13625,36 @@ class Graph:
             if not silent:
                 print("Graph.Difference - Error: The graphB input parameter is not a valid graph. Returning None.")
             return None
-        if not isinstance(vertexKey, str):
-            if not silent:
-                print("Graph.Difference - Error: The vertexKey input parameter is not a valid string. Returning None.")
-            return None
+
         vertices_a = Graph.Vertices(graphA)
+        vertices_a_new = []
+        for v in vertices_a:
+            d = Topology.Dictionary(v)
+            v_new = Vertex.ByCoordinates(Vertex.Coordinates(v))
+            v_new = Topology.SetDictionary(v_new, d)
+            vertices_a_new.append(v_new)
+        vertices_a = vertices_a_new
         vertices_b = Graph.Vertices(graphB)
+        vertices_b_new = []
+        for v in vertices_b:
+            d = Topology.Dictionary(v)
+            v_new = Vertex.ByCoordinates(Vertex.Coordinates(v))
+            v_new = Topology.SetDictionary(v_new, d)
+            vertices_b_new.append(v_new)
+        vertices_b = vertices_b_new
         mesh_data_a = Graph.MeshData(graphA)
         mesh_data_b = Graph.MeshData(graphB)
         edges_a = mesh_data_a['edges']
         edges_b = mesh_data_b['edges']
         edges_a_dicts = mesh_data_a['edgeDictionaries']
 
-        diff_vertices = [v for v in vertices_a if not Graph._vertex_in_list(v, vertices_b, key=vertexKey)]
+        diff_vertices = [v for v in vertices_a if not Graph._vertex_in_list(v, vertices_b, keys=vertexKeys, tolerance=tolerance)]
         diff_edges = []
 
         for i, e in enumerate(edges_a):
-            if not Graph._edge_in_list(e, edges_b, vertices_a, vertices_b, key=vertexKey):
+            if not Graph._edge_in_list(e, edges_b, vertices_a, vertices_b, keys=vertexKeys, tolerance=tolerance):
                 # Create the edge
-                if Graph._vertex_in_list(vertices_a[e[0]], diff_vertices, key=vertexKey) and Graph._vertex_in_list(vertices_a[e[1]], diff_vertices, key=vertexKey):
+                if Graph._vertex_in_list(vertices_a[e[0]], diff_vertices, keys=vertexKeys, tolerance=tolerance) and Graph._vertex_in_list(vertices_a[e[1]], diff_vertices, keys=vertexKeys, tolerance=tolerance):
                     final_edge = Edge.ByVertices(vertices_a[e[0]], vertices_a[e[1]])
                     # Set the edge's dictionary
                     final_edge = Topology.SetDictionary(final_edge, Dictionary.ByPythonDictionary(edges_a_dicts[i]), silent=True)
@@ -13212,9 +13664,9 @@ class Graph:
         return Graph.ByVerticesEdges(diff_vertices, diff_edges)
 
     @staticmethod
-    def SymmetricDifference(graphA, graphB, vertexKey: str, silent: bool = False):
+    def Merge(graphA, graphB, vertexKeys=None, vertexColorKey="color", useCentroid: bool = False, tolerance: float = 0.0001, silent: bool = False):
         """
-        Find the symmetric difference pf the two input graphs based on an input vertex key. See https://en.wikipedia.org/wiki/Boolean_operation.
+        Merges the two input graphs based on the input vertex keys. This is an alias for Graph.Union. See https://en.wikipedia.org/wiki/Boolean_operation.
 
         Parameters
         ----------
@@ -13222,8 +13674,57 @@ class Graph:
             The first input graph.
         graphB : topologic_core.Graph
             The second input graph.
-        vertexKey : str
-            The vertex dictionary key to use to determine if two vertices are the same. 
+        vertexKeys : list or str , optional
+            The vertex dictionary key (str) or keys (list of str) to use to determine if two vertices are the same.
+            If the vertexKeys are set to None or "loc" or "coord" or "xyz" (case insensitive), the distance between the
+            vertices (within the tolerance) will be used to determine sameness. The default is None.
+        vertexColorKey : str , optional
+            The dictionary key that is storing the vertex's color. The final colors will be averaged. The default is "color".
+        useCentroid : bool , optional
+            If set to True, the coordinates of identical vertices from each graph are averaged to located the new merged vertex of the resulting graph.
+            Otherwise, the coordinates of the vertex of the first input graph are used. The default is False.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. The default is False.
+        
+        Returns
+        -------
+        topologic_core.Graph
+            the resultant graph. Vertex and edge dictionaries are merged.
+
+        """
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graphA, "graph"):
+            if not silent:
+                print("Graph.Union - Error: The graphA input parameter is not a valid graph. Returning None.")
+            return None
+        if not Topology.IsInstance(graphB, "graph"):
+            if not silent:
+                print("Graph.Union - Error: The graphB input parameter is not a valid graph. Returning None.")
+            return None
+        return Graph.Union(graphA, graphB, vertexKeys=vertexKeys, vertexColorKey=vertexColorKey, useCentroid=useCentroid, tolerance=tolerance, silent=silent)
+    
+    @staticmethod
+    def SymmetricDifference(graphA, graphB, vertexKeys, useCentroid: bool = False, tolerance: float = 0.001, silent: bool = False):
+        """
+        Find the symmetric difference (exclusive OR / XOR) of the two input graphs based on the input vertex keys. See https://en.wikipedia.org/wiki/Boolean_operation.
+
+        Parameters
+        ----------
+        graphA : topologic_core.Graph
+            The first input graph.
+        graphB : topologic_core.Graph
+            The second input graph.
+        vertexKeys : list or str , optional
+            The vertex dictionary key (str) or keys (list of str) to use to determine if two vertices are the same.
+            If the vertexKeys are set to None or "loc" or "coord" or "xyz" (case insensitive), the distance between the
+            vertices (within the tolerance) will be used to determine sameness. The default is None.
+        useCentroid : bool , optional
+            This is not used here, but included for API consistency for boolean operations.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
         silent : bool , optional
             If set to True, error and warning messages are suppressed. The default is False.
 
@@ -13244,10 +13745,49 @@ class Graph:
             if not silent:
                 print("Graph.SymmetricDifference - Error: The graphB input parameter is not a valid graph. Returning None.")
             return None
-        if not isinstance(vertexKey, str):
+        diffAB = Graph.Difference(graphA, graphB, vertexKeys=vertexKeys, useCentroid=useCentroid, tolerance=tolerance, silent=True)
+        diffBA = Graph.Difference(graphB, graphA, vertexKeys=vertexKeys, useCentroid=useCentroid, tolerance=tolerance, silent=True)
+        return Graph.Union(diffAB, diffBA, vertexKeys=vertexKeys, useCentroid=useCentroid, tolerance=tolerance, silent=True)
+    
+    @staticmethod
+    def XOR(graphA, graphB, vertexKeys, useCentroid: bool = False, tolerance: float = 0.001, silent: bool = False):
+        """
+        Find the symmetric difference (exclusive OR / XOR) of the two input graphs based on an input vertex key. See https://en.wikipedia.org/wiki/Boolean_operation.
+
+        Parameters
+        ----------
+        graphA : topologic_core.Graph
+            The first input graph.
+        graphB : topologic_core.Graph
+            The second input graph.
+        vertexKeys : list or str , optional
+            The vertex dictionary key (str) or keys (list of str) to use to determine if two vertices are the same.
+            If the vertexKeys are set to None or "loc" or "coord" or "xyz" (case insensitive), the distance between the
+            vertices (within the tolerance) will be used to determine sameness. The default is None.
+        useCentroid : bool , optional
+            This is not used here, but included for API consistency for boolean operations.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. The default is False.
+
+        Returns
+        -------
+        topologic_core.Graph
+            the resultant graph. Vertex and edge dictionaries are not merged.
+
+        """
+
+        from topologicpy.Topology import Topology
+
+        if not Topology.IsInstance(graphA, "graph"):
+            if not silent:
+                print("Graph.XOR - Error: The graphA input parameter is not a valid graph. Returning None.")
+            return None
+        if not Topology.IsInstance(graphB, "graph"):
             if not silent:
-                print("Graph.SymmetricDifference - Error: The vertexKey input parameter is not a valid string. Returning None.")
+                print("Graph.XOR - Error: The graphB input parameter is not a valid graph. Returning None.")
             return None
-        diffAB = Graph.Difference(graphA, graphB, vertexKey=vertexKey, silent=True)
-        diffBA = Graph.Difference(graphB, graphA, vertexKey=vertexKey, silent=True)
-        return Graph.Union(diffAB, diffBA, vertexKey=vertexKey, silent=True)
+        diffAB = Graph.Difference(graphA, graphB, vertexKeys=vertexKeys, useCentroid=useCentroid, tolerance=tolerance, silent=True)
+        diffBA = Graph.Difference(graphB, graphA, vertexKeys=vertexKeys, useCentroid=useCentroid, tolerance=tolerance, silent=True)
+        return Graph.Union(diffAB, diffBA, vertexKeys=vertexKeys, useCentroid=useCentroid, tolerance=tolerance, silent=True)

topologicpy/Plotly.py

@@ -277,6 +277,9 @@ class Plotly:
                     absolute: bool = False,
                     sides: int = 8,
                     angle: float = 0,
+                    directed: bool = False,
+                    arrowSize: int = 0.1,
+                    arrowSizeKey: str = None,
                     vertexColor: str = "black",
                     vertexColorKey: str = None,
                     vertexSize: float = 10,
@@ -330,6 +333,12 @@ class Plotly:
             For example, if the length of the edge is 10, the sagitta is set to 0.5, and absolute is set to False, the sagitta length will be 5. The default is True.
         sides : int , optional
             The number of sides of the arc. The default is 8.
+        directed : bool , optional
+            If set to True, arrowheads are drawn to show direction. The default is False.
+        arrowSize : int, optional
+            The desired size of arrowheads for directed graphs. The default is 0.1.
+        arrowSizeKey: str , optional
+            The edge dictionary key under which to find the arrowhead size. The default is None.
         vertexColor : str , optional
             The desired color of the output vertices. This can be any plotly color string and may be specified as:
             - A hex string (e.g. '#ff0000')
@@ -479,7 +488,7 @@ 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, dash=edgeDash, dashKey=edgeDashKey, labelKey=edgeLabelKey, showEdgeLabel=showEdgeLabel, groupKey=edgeGroupKey, minGroup=edgeMinGroup, maxGroup=edgeMaxGroup, groups=edgeGroups, legendLabel=edgeLegendLabel, legendGroup=edgeLegendGroup, legendRank=edgeLegendRank, showLegend=showEdgeLegend, colorScale=colorScale))        
+                data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, dash=edgeDash, dashKey=edgeDashKey, directed=directed, arrowSize=arrowSize, arrowSizeKey=arrowSizeKey, 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
@@ -638,11 +647,60 @@ class Plotly:
         return return_value
 
     @staticmethod
-    def edgeData(vertices, edges, dictionaries=None, color="black", colorKey=None, width=1, widthKey=None, dash=False, dashKey=None, labelKey=None, showEdgeLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Edges", legendGroup=2, legendRank=2, showLegend=True, colorScale="Viridis"):
+    def edgeData(vertices, edges, dictionaries=None, color="black", colorKey=None, width=1, widthKey=None, dash=False, dashKey=None, directed=False, arrowSize=0.1, arrowSizeKey=None, labelKey=None, showEdgeLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Edges", legendGroup=2, legendRank=2, showLegend=True, colorScale="Viridis"):
     
         from topologicpy.Color import Color
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Helper import Helper
+
+        def create_arrowheads(x, y, z, arrowSize=4):
+            import plotly.graph_objects as go
+            import numpy as np
+
+            arrow_traces = []
+
+            # Compute segment directions
+            cone_x, cone_y, cone_z = [], [], []
+            cone_u, cone_v, cone_w = [], [], []
+
+            for i in range(len(x) - 1):
+                if x[i] == None or x[i+1] == None:
+                    continue
+                u = x[i+1] - x[i]
+                v = y[i+1] - y[i]
+                w = z[i+1] - z[i]
+
+                norm = np.linalg.norm([u, v, w])
+                if norm > 0:
+                    u /= norm
+                    v /= norm
+                    w /= norm
+                    cone_x.append(x[i+1])
+                    cone_y.append(y[i+1])
+                    cone_z.append(z[i+1])
+                    cone_u.append(u)
+                    cone_v.append(v)
+                    cone_w.append(w)
+
+            cone_trace = go.Cone(
+                x=cone_x,
+                y=cone_y,
+                z=cone_z,
+                u=cone_u,
+                v=cone_v,
+                w=cone_w,
+                sizemode="raw",
+                sizeref=arrowSize,
+                showscale=False,
+                colorscale=[[0, color], [1, color]],
+                anchor="tip",
+                name="",  # Hide legend
+                hoverinfo="skip",
+                showlegend=False
+            )
+            arrow_traces.append(cone_trace)
+
+            return arrow_traces
         traces = []
         x = []
         y = []
@@ -676,8 +734,8 @@ class Plotly:
             maxGroup = 1
         
 
-        if colorKey or widthKey or labelKey or groupKey or dashKey:
-            keys = [x for x in [colorKey, widthKey, labelKey, groupKey, dashKey] if not x == None]
+        if colorKey or widthKey or labelKey or groupKey or dashKey or arrowSizeKey:
+            keys = [x for x in [colorKey, widthKey, labelKey, groupKey, dashKey, arrowSizeKey] if not x == None]
             temp_dict = Helper.ClusterByKeys(edges, dictionaries, keys, silent=False)
             dict_clusters = temp_dict["dictionaries"]
             elements_clusters = temp_dict['elements']
@@ -692,6 +750,8 @@ class Plotly:
                         d_color = Color.AnyToHex(d_color)
                     if not dashKey == None:
                         d_dash = Dictionary.ValueAtKey(d, key=dashKey) or dash
+                    if not arrowSizeKey == None:
+                        d_arrowSize = Dictionary.ValueAtKey(d, key=arrowSizeKey) or arrowSize
                     if not labelKey == None:
                         labels.append(str(Dictionary.ValueAtKey(d, labelKey, "")))
                     if not widthKey == None:
@@ -744,6 +804,9 @@ class Plotly:
                                     text=labels,
                                     hoverinfo='text',
                                     hovertext=labels)
+                if directed:
+                    arrow_traces = create_arrowheads(x, y, z, arrowSize=d_arrowSize)
+                    traces += arrow_traces
                 traces.append(trace)
         else:
             x = []
@@ -775,6 +838,9 @@ class Plotly:
                                 legendrank=legendRank,
                                 text=label,
                                 hoverinfo='text')
+            if directed:
+                arrow_traces = create_arrowheads(x, y, z, arrowSize=arrowSize)
+                traces += arrow_traces
             traces.append(trace)
         return traces
 
@@ -799,6 +865,9 @@ class Plotly:
                        vertexLegendLabel="Topology Vertices",
                        vertexLegendRank=1,
                        vertexLegendGroup=1,
+                       directed=False,
+                       arrowSize=0.1,
+                       arrowSizeKey=None,
                        showEdges=True,
                        edgeWidth=1,
                        edgeWidthKey=None,
@@ -884,7 +953,12 @@ class Plotly:
             The legend rank order of the vertices of this topology. The default is 1.
         vertexLegendGroup : int , optional
             The number of the vertex legend group to which the vertices of this topology belong. The default is 1.
-        
+        directed : bool , optional
+            If set to True, arrowheads are drawn to show direction. The default is False.
+        arrowSize : int, optional
+            The desired size of arrowheads for directed graphs. The default is 0.1.
+        arrowSizeKey: str , optional
+            The edge dictionary key under which to find the arrowhead size. The default is None.
         showEdges : bool , optional
             If set to True the edges will be drawn. Otherwise, they will not be drawn. The default is True.
         edgeWidth : float , optional
@@ -1194,7 +1268,7 @@ class Plotly:
                 vertices = geo['vertices']
                 edges = geo['edges']
                 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))
+                    data.extend(Plotly.edgeData(vertices, edges, dictionaries=e_dictionaries, color=edgeColor, colorKey=edgeColorKey, width=edgeWidth, widthKey=edgeWidthKey, directed=directed, arrowSize=arrowSize, arrowSizeKey=arrowSizeKey, 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:

topologicpy/Topology.py

@@ -8162,7 +8162,10 @@ class Topology():
              vertexMaxGroup=None, 
              showVertexLegend=False,
              vertexLegendLabel="Vertices",
-
+             
+             directed=False,
+             arrowSize=0.1,
+             arrowSizeKey=None,
              showEdges=True,
              edgeWidth=None,
              edgeWidthKey=None,
@@ -8281,7 +8284,12 @@ class Topology():
             If set to True, the legend for the vertices of this topology is shown. Otherwise, it isn't. The default is False.
         vertexLegendLabel : str , optional
             The legend label string used to identify vertices. The default is "Topology Vertices".
-        
+        directed : bool , optional
+            If set to True, arrowheads are drawn to show direction. The default is False.
+        arrowSize : int, optional
+            The desired size of arrowheads for directed graphs. The default is 0.1.
+        arrowSizeKey: str , optional
+            The edge dictionary key under which to find the arrowhead size. The default is None.
         showEdges : bool , optional
             If set to True the edges will be drawn. Otherwise, they will not be drawn. The default is True.
         edgeWidth : float , optional
@@ -8470,6 +8478,9 @@ class Topology():
                                            absolute=absolute,
                                            sides=sides,
                                            angle=angle,
+                                           directed=directed,
+                                           arrowSize=arrowSize,
+                                           arrowSizeKey=arrowSizeKey,
                                            vertexColor=vertexColor,
                                            vertexColorKey=vertexColorKey,
                                            vertexSize=vSize,
@@ -8543,6 +8554,9 @@ class Topology():
                                               vertexLegendLabel=str(i+1)+": "+name+" ("+vertexLegendLabel+")",
                                               vertexLegendRank=topology_counter+1,
                                               vertexLegendGroup=topology_counter+1,
+                                              directed=directed,
+                                              arrowSize=arrowSize,
+                                              arrowSizeKey=arrowSizeKey,
                                               showEdges=showEdges,
                                               edgeWidth=eWidth,
                                               edgeWidthKey=edgeWidthKey,

topologicpy/Vertex.py

@@ -1819,7 +1819,7 @@ class Vertex():
         return Vertex.ByCoordinates(pt[0], pt[1], pt[2])
 
     @staticmethod
-    def Separate(*vertices, minDistance: float = 0.0001, silent: bool = False):
+    def Separate(*vertices, minDistance: float = 0.0001, iterations: int = 100, strength: float = 0.1, tolerance: float = 0.0001, silent: bool = False):
         """
         Separates the input vertices such that no two vertices are within the input minimum distance.
 
@@ -1829,6 +1829,12 @@ class Vertex():
             One or more instances of a topologic vertex to be processed.
         minDistance : float , optional
             The desired minimum distance. The default is 0.0001.
+        iterations : int
+            The number of iterations to run the repulsion simulation. The default is 100.
+        strength : float
+            The force multiplier controlling how strongly vertices repel each other. The default is 0.1.
+        tolerance : float
+            The desired tolerance. The default is 0.0001.
         silent : bool , optional
                 If set to True, error and warning messages are suppressed. The default is False.
 
@@ -1840,10 +1846,7 @@ class Vertex():
         """
         from topologicpy.Topology import Topology
         from topologicpy.Helper import Helper
-        from topologicpy.Dictionary import Dictionary
-        from math import sqrt
-        from scipy.spatial import KDTree
-        import numpy as np
+        import math
 
         if len(vertices) == 0:
             if not silent:
@@ -1873,33 +1876,37 @@ class Vertex():
             if not silent:
                 print("Vertex.Separate - Error: The input parameters do not contain any valid vertices. Returning None.")
             return None
-    
-        coords = np.array([[v.X(), v.Y(), v.Z()] for v in vertexList])  # Extract coordinates
-        tree = KDTree(coords)  # Build k-d tree for efficient neighbor search
+
+        minDistance = minDistance + tolerance # Add a bit of a safety factor
+
+        # Convert to mutable coordinates
+        coords = [[v.X(), v.Y(), v.Z()] for v in vertices]
+        
+        for _ in range(iterations):
+            for i in range(len(coords)):
+                for j in range(i + 1, len(coords)):
+                    dx = coords[j][0] - coords[i][0]
+                    dy = coords[j][1] - coords[i][1]
+                    dz = coords[j][2] - coords[i][2]
+                    dist = math.sqrt(dx*dx + dy*dy + dz*dz)
+                    
+                    if dist < minDistance and dist > 1e-9:
+                        # Calculate repulsion vector
+                        repel = (minDistance - dist) / dist * strength
+                        shift = [dx * repel * 0.5, dy * repel * 0.5, dz * repel * 0.5]
+                        coords[i][0] -= shift[0]
+                        coords[i][1] -= shift[1]
+                        coords[i][2] -= shift[2]
+                        coords[j][0] += shift[0]
+                        coords[j][1] += shift[1]
+                        coords[j][2] += shift[2]
         
-        for i, vertex in enumerate(coords):
-            neighbors = tree.query_ball_point(vertex, minDistance)
-            for neighbor_index in neighbors:
-                if neighbor_index != i:  # Avoid self-comparison
-                    direction = coords[neighbor_index] - vertex
-                    distance = np.linalg.norm(direction)
-                    if distance < minDistance:
-                        # Move current vertex away from its neighbor
-                        adjustment = (minDistance - distance) / 2
-                        unit_vector = direction / distance if distance != 0 else np.random.rand(3)
-                        coords[i] -= unit_vector * adjustment
-                        coords[neighbor_index] += unit_vector * adjustment
-
-            # Rebuild the k-d tree after adjustment
-            tree = KDTree(coords)
-
-        # Convert adjusted coordinates back to Vertex objects
-        separated_vertices = [Vertex.ByCoordinates(x, y, z) for x, y, z in coords]
-        for i, vertex in enumerate(vertexList):
-            d = Topology.Dictionary(vertex)
-            if len(Dictionary.Keys(d)) > 0:
-                separated_vertices[i] = Topology.SetDictionary(separated_vertices[i], d)
-        return separated_vertices
+        # Reconstruct TopologicPy Vertex objects
+        new_vertices = [Vertex.ByCoordinates(x, y, z) for x, y, z in coords]
+        # Transfer the dictionaries
+        for i, v in enumerate(new_vertices):
+            v = Topology.SetDictionary(v, Topology.Dictionary(vertices[i]))
+        return new_vertices
 
     @staticmethod
     def Transform(vertex, matrix, mantissa: int = 6, silent: bool = False):

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.39'
+__version__ = '0.8.41'

{topologicpy-0.8.39.dist-info → topologicpy-0.8.41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.39
+Version: 0.8.41
 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.8.39.dist-info → topologicpy-0.8.41.dist-info}/RECORD

@@ -5,34 +5,34 @@ topologicpy/CSG.py,sha256=uDkOSmc8m1V_k7T3UCerODhOSyYNO4FRDzoOqt0kEt8,15590
 topologicpy/Cell.py,sha256=3et98bv27m1-7OqFCeD4cLMBgC_BAsSGyxHi_4PgJ4Y,176072
 topologicpy/CellComplex.py,sha256=NP6yptbkGXYmlfBv9fRimOnNle0mkjV8Yo_ug5NKpKE,60877
 topologicpy/Cluster.py,sha256=wvfMAx6aPrSAt5nQ4--KnqD4EK9MGjch6Dg985WF7JQ,58748
-topologicpy/Color.py,sha256=ZVVQRKGjebY9aOU1gpN_AbssdRRiVKlZV3f8TrsTNgg,20307
+topologicpy/Color.py,sha256=FcR0-__giyGQqvgiOrG8GkA65arHbiS33Si-QbUADPI,23362
 topologicpy/Context.py,sha256=G3CwMvN8Jw2rnQRwB-n4MaQq_wLS0vPimbXKwsdMJ80,3055
 topologicpy/DGL.py,sha256=HQXy9iDnrvWGDxaBfe5pRbweQ2zLBvAf6UdjfhKkQYI,139041
 topologicpy/Dictionary.py,sha256=2Sxm8twR1W4ksZho0YXQB_EltK2qbZWK4UHskP3jvFQ,40846
 topologicpy/Edge.py,sha256=CPdQKaE7ft6zgh0vxekkfGRRUY_yEqkEJ14NvjSgJOA,73190
 topologicpy/EnergyModel.py,sha256=Pyb28gDDwhzlQIH0xqAygqS0P3SJxWyyV7OWS_AAfRs,53856
 topologicpy/Face.py,sha256=BT_5ymb7-s-Wb1tuaBtkopJpeNg-RbooTUk_-KInQ6c,201618
-topologicpy/Graph.py,sha256=YLigYjWAAhMMtUurYngjK9NUMLkDM08BmYWYjxYwMcs,620455
+topologicpy/Graph.py,sha256=GykBbB8KKcy2oPV2Dsnz_vkyWGgczxLi0puVx5NJUYU,648088
 topologicpy/Grid.py,sha256=EbI2NcYhQDpD5mItd7A1Lpr8Puuf87vZPWuoh7_gChQ,18483
 topologicpy/Helper.py,sha256=qEsE4yaboEGW94q9lFCff0I_JwwTTQnDAFXw006yHaQ,31203
 topologicpy/Honeybee.py,sha256=yctkwfdupKnp7bAOjP1Z4YaYpRrWoMEb4gz9Z5zaWwE,21751
 topologicpy/Matrix.py,sha256=LqVckk2qTwKwEo79eyNsOrHVSHdO82JCREcfy6WIk4I,22716
 topologicpy/Neo4j.py,sha256=ELKmON7R16j1kQD8xRHDGGCvzjIM2HGHNekdaXDUw6w,22371
-topologicpy/Plotly.py,sha256=Dmy9i9puSfvB42mrBUip3v0TCXIzHpAETWDUCDxfqNA,120556
+topologicpy/Plotly.py,sha256=3jTy-bFNS_zFsfqpY_WdhHlt9kdexDq_Jvp5jxR16tQ,123710
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=zvV6jtnol_aFiN6JRoMpYwBVfOU2aFs9gdWSdEo6mtU,109757
 topologicpy/ShapeGrammar.py,sha256=UVb8VPwVKd6V3zDTNzpBecQPgYo1EjSsS10XJ8k5YcI,23364
 topologicpy/Shell.py,sha256=fx0WTndC8blkvWe38nKsJsI_AmklOA0qsjU0gbZp4b4,90501
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=_VBBAUIDhvpkp72JBZlv7k9qx9jYubm3yM56UZ1Nc6c,36837
-topologicpy/Topology.py,sha256=G6KtKRKabV1gNUKCZ3rzZJkCogGkOJDnCl-_S7DuHKc,466648
+topologicpy/Topology.py,sha256=hGjePUb2-1MmyMva9nNtPiWr4CAWMa__BGX17mIOHfA,467519
 topologicpy/Vector.py,sha256=X12eqskn28bdB7sLY1EZhq3noPYzPbNEgHPb4a959ss,42302
-topologicpy/Vertex.py,sha256=epBfbD7fm87T-TZ0WuwrioXdYqg9NgRlHn_qUFtVbkc,84562
+topologicpy/Vertex.py,sha256=RlGQnxQSb_kAus3tJgXd-v-Ptubtt09PQPA9IMwfXmI,84835
 topologicpy/Wire.py,sha256=vE6IoObVucOZVTFMPiHuNN4DDezRHHyFbwhF5WRBm3s,231547
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=krvNarxqLr-1e4M5aYKlWbcRZoZxDYVlZehTgEbpBTg,23
-topologicpy-0.8.39.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.39.dist-info/METADATA,sha256=l1XGyTl1wZZ-G4PgjDEzyZ_kitEAFGAGhcgW8wV1Jos,10535
-topologicpy-0.8.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.39.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.39.dist-info/RECORD,,
+topologicpy/version.py,sha256=tObOvnnCfxEdJFf4I6CjFR-B5fIFs3s0EygfFnJZgQM,23
+topologicpy-0.8.41.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.41.dist-info/METADATA,sha256=Fqkthwxq-nQkwkhyhz3ZvFA9C4tU6vPVwo2i3Q9QVmU,10535
+topologicpy-0.8.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.41.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.41.dist-info/RECORD,,