topologicpy 0.8.38__py3-none-any.whl → 0.8.40__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/Dictionary.py

@@ -324,6 +324,7 @@ class Dictionary():
             return new_dictionaries[0]
         else:
             dictionaries = return_dictionaries
+        
         sinkKeys = []
         sinkValues = []
         d = dictionaries[0]

topologicpy/Graph.py

@@ -6295,7 +6295,9 @@ class Graph:
         if not vertices:
             edges = []
             _ = graph.Edges(edges, tolerance) # Hook to Core
-            return edges
+            if not edges:
+                return []
+            return list(dict.fromkeys(edges)) # remove duplicates
         else:
             vertices = [v for v in vertices if Topology.IsInstance(v, "Vertex")]
         if len(vertices) < 1:
@@ -12909,4 +12911,719 @@ class Graph:
         numerator = sum(min(weights1.get(k, 0), weights2.get(k, 0)) for k in keys)
         denominator = sum(max(weights1.get(k, 0), weights2.get(k, 0)) for k in keys)
 
-        return round(numerator / denominator, mantissa) if denominator != 0 else 0.0
+        return round(numerator / denominator, mantissa) if denominator != 0 else 0.0
+
+    @staticmethod
+    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, 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, keys=None, tolerance=0.0001):
+        for i, v1 in enumerate(vertex_list):
+            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, 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, 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, vertexKeys=None, useCentroid: bool = False, tolerance: float = 0.0001, silent: bool = False):
+        """
+        Union 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.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Cluster import Cluster
+
+        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
+        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_a = Topology.Dictionary(v)
+                    d_b = Topology.Dictionary(uv)
+                    d_c = Dictionary.ByMergedDictionaries(d_a, d_b)
+                    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
+
+        # 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)):
+                    # Merge dictionaries
+                    d_a = Topology.Dictionary(e)
+                    d_c = Dictionary.ByMergedDictionaries([d_a, dictionary], silent=True)
+                    new_edge = Edge.ByVertices(vi, vj)
+                    new_edge = Topology.SetDictionary(new_edge, d_c, 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 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 Imprint(graphA, graphB, vertexKeys, useCentroid: bool = False, tolerance: float = 0.0001, silent: bool = False):
+        """
+        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
+        ----------
+        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.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.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 Topology.IsInstance(graphB, "graph"):
+            if not silent:
+                print("Graph.Intersect - 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']
+
+        common_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_a = Topology.Dictionary(a)
+                d_b = Topology.Dictionary(b)
+                d_c = Dictionary.ByMergedDictionaries([d_a, d_b], silent=True)
+                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, 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)
+                # 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
+                common_edges.append(final_edge)
+
+        return Graph.ByVerticesEdges(common_vertices, common_edges)
+
+    @staticmethod
+    def Difference(graphA, graphB, vertexKeys, 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
+            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.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        if not Topology.IsInstance(graphA, "graph"):
+            if not silent:
+                print("Graph.Difference - 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.Difference - 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']
+
+        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, keys=vertexKeys, tolerance=tolerance):
+                # Create the edge
+                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)
+                    # Add the final edge to the list
+                    diff_edges.append(final_edge)
+
+        return Graph.ByVerticesEdges(diff_vertices, diff_edges)
+
+    @staticmethod
+    def Merge(graphA, graphB, vertexKeys=None, vertexColorKey="color", useCentroid: bool = False, tolerance: float = 0.0001, silent: bool = False):
+        """
+        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
+        ----------
+        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.
+        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.
+
+        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.SymmetricDifference - 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 graphB input parameter is not a valid graph. Returning None.")
+            return None
+        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.XOR - Error: The graphB input parameter is not a valid graph. Returning None.")
+            return None
+        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

@@ -551,7 +551,7 @@ class Plotly:
                         if not labelKey == None:
                             labels[m] = Dictionary.ValueAtKey(d, key=labelKey, defaultValue=" ")
                         if not sizeKey == None:
-                            sizes[m] = float(Dictionary.ValueAtKey(d, key=sizeKey))
+                            sizes[m] = float(Dictionary.ValueAtKey(d, key=sizeKey, defaultValue=sizes[m]))
                             if sizes[m] == None:
                                sizes[m] = size
                             if float(sizes[m]) <= 0:

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.38'
+__version__ = '0.8.40'

{topologicpy-0.8.38.dist-info → topologicpy-0.8.40.dist-info}/METADATA

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

@@ -5,20 +5,20 @@ 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=PageNwgFmLakb0cKizsCEGkL_u_JV0CVqYGRM60XdsI,40837
+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=e9_KSCvRI8jilx7afqicPDJqsCPHA5ucz5To8mfbFKo,605658
+topologicpy/Graph.py,sha256=z_9TeMkmwFXlCfVDW9Z56PX0sHxGj8iVKlCdJLreMo0,639785
 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=B6CxNyAGfhv70N6sa4B4aHLYd7zIpH5S1hmpk3sQ3ys,120533
+topologicpy/Plotly.py,sha256=Dmy9i9puSfvB42mrBUip3v0TCXIzHpAETWDUCDxfqNA,120556
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=zvV6jtnol_aFiN6JRoMpYwBVfOU2aFs9gdWSdEo6mtU,109757
 topologicpy/ShapeGrammar.py,sha256=UVb8VPwVKd6V3zDTNzpBecQPgYo1EjSsS10XJ8k5YcI,23364
@@ -30,9 +30,9 @@ topologicpy/Vector.py,sha256=X12eqskn28bdB7sLY1EZhq3noPYzPbNEgHPb4a959ss,42302
 topologicpy/Vertex.py,sha256=epBfbD7fm87T-TZ0WuwrioXdYqg9NgRlHn_qUFtVbkc,84562
 topologicpy/Wire.py,sha256=vE6IoObVucOZVTFMPiHuNN4DDezRHHyFbwhF5WRBm3s,231547
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=K8Qib--QiI1qx6hx2xqHbVpHiSCs5RJ_6E-TRDxr1Y8,23
-topologicpy-0.8.38.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.38.dist-info/METADATA,sha256=ebAGBKEzxeo5cll1YKrRoo-G0mOx6Dwzmwsl246AwYo,10535
-topologicpy-0.8.38.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.38.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.38.dist-info/RECORD,,
+topologicpy/version.py,sha256=9UtSkYQrOL8TXxQBwLoy5jvQKNWp84nSX32fmM7V0Ac,23
+topologicpy-0.8.40.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.40.dist-info/METADATA,sha256=8YuR3I1XDjArnIbbajaveZEDc7Q8eVk4aBOvtaLhULA,10535
+topologicpy-0.8.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.40.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.40.dist-info/RECORD,,