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

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,343 @@ 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, key=None):
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+        d1 = Topology.Dictionary(v1)
+        d2 = Topology.Dictionary(v2)
+        a = Dictionary.ValueAtKey(d1, key, "0")
+        b = Dictionary.ValueAtKey(d2, key, "1")
+        return a == b
+
+    @staticmethod
+    def _vertex_in_list(vertex, vertex_list, key=None):
+        for i, v1 in enumerate(vertex_list):
+            if Graph._vertex_is_same(vertex, v1, key=key):
+                return i+1
+        return False
+
+    @staticmethod
+    def _edge_in_list(edge, edge_list, vertices_a, vertices_b, key=None):
+        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)):
+                return i+1
+        return False
+
+    @staticmethod
+    def Union(graphA, graphB, vertexKey: str, silent: bool = False):
+        """
+        Union 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.
+        vertexKey : str
+            The vertex dictionary key to use to determine if two vertices are the same. 
+        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
+
+        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
+        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:
+            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, key=vertexKey):
+                    d_a = Topology.Dictionary(v)
+                    d_b = Topology.Dictionary(uv)
+                    d_c = Dictionary.ByMergedDictionaries(d_a, d_b)
+                    uv = Topology.SetDictionary(uv, d_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, 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)):
+                    # 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]]
+            _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]))
+
+        return Graph.ByVerticesEdges(union_vertices, union_edges)
+
+    @staticmethod
+    def Intersect(graphA, graphB, vertexKey: str, silent: bool = False):
+        """
+        Intersect 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.
+        vertexKey : str
+            The vertex dictionary key to use to determine if two vertices are the same. 
+        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
+
+        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
+        if not isinstance(vertexKey, str):
+            if not silent:
+                print("Graph.Intersect - 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']
+        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)
+            if j:
+                d_a = Topology.Dictionary(v)
+                d_b = Topology.Dictionary(vertices_b[j-1])
+                d_c = Dictionary.ByMergedDictionaries([d_a, d_b], silent=True)
+                v = Topology.SetDictionary(v, d_c, silent=True)
+                common_vertices.append(v)
+        common_edges = []
+
+        for i, e in enumerate(edges_a):
+            j = Graph._edge_in_list(e, edges_b, vertices_a, vertices_b, key=vertexKey)
+            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]])
+                # 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, vertexKey: str, silent: bool = False):
+        """
+        Intersect 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.
+        vertexKey : str
+            The vertex dictionary key to use to determine if two vertices are the same. 
+        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
+        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_b = Graph.Vertices(graphB)
+        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_edges = []
+
+        for i, e in enumerate(edges_a):
+            if not Graph._edge_in_list(e, edges_b, vertices_a, vertices_b, key=vertexKey):
+                # 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):
+                    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 SymmetricDifference(graphA, graphB, vertexKey: str, 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.
+
+        Parameters
+        ----------
+        graphA : topologic_core.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. 
+        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
+        if not isinstance(vertexKey, str):
+            if not silent:
+                print("Graph.SymmetricDifference - Error: The vertexKey input parameter is not a valid string. 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)

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.39'

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

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

@@ -8,17 +8,17 @@ topologicpy/Cluster.py,sha256=wvfMAx6aPrSAt5nQ4--KnqD4EK9MGjch6Dg985WF7JQ,58748
 topologicpy/Color.py,sha256=ZVVQRKGjebY9aOU1gpN_AbssdRRiVKlZV3f8TrsTNgg,20307
 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=YLigYjWAAhMMtUurYngjK9NUMLkDM08BmYWYjxYwMcs,620455
 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=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,,