topologicpy 0.8.18__py3-none-any.whl → 0.8.20__py3-none-any.whl

topologicpy/Graph.py

@@ -4377,6 +4377,220 @@ class Graph:
                 v = Topology.SetDictionary(v, d)
         return graph
     
+    @staticmethod
+    def Compare(graphA, graphB,
+                weightAttributes: float = 1.0,
+                weightGeometry: float = 1.0,
+                weightMetrics: float = 1.0,
+                weightStructure: float = 1.0,
+                weightWL: float = 1.0,
+                iterations: int = 3,
+                mantissa: int = 6,
+                silent: bool = False):
+        """
+        Compares two graphs and returns a similarity score based on attributres, geometry, metrics, structure, and
+        the Weisfeiler-Lehman graph kernel. See https://en.wikipedia.org/wiki/Weisfeiler_Leman_graph_isomorphism_test
+
+        Parameters
+        ----------
+        graphA : topologic Graph
+            The first input graph.
+        graphB : topologic Graph
+            The second input graph.
+        weightAttributes : float , optional
+            The desired weight for attribute similarity (dictionary key overlap at vertices). Default is 1.0.
+        weightGeometry : float , optional
+            The desired weight for geometric similarity (vertex positions). Default is 1.0.
+        weightMetrics : float , optional
+            The desired weight for metric similarity (graph-level and node-level). Default is 1.0.
+            The compared metrics are: betweenness centrality, closeness centrality, clustering coefficient, degree, diameter, and pagerank.
+        weightStructure : float , optional
+            The desired weight for structural similarity (number of vertices and edges). Default is 1.0.
+        weightWL : float , optional
+            The desired weight for Weisfeiler-Lehman kernel similarity (iterative label propagation). Default is 1.0.
+        iterations : int , optional
+            The desired number of Weisfeiler-Lehman iterations. Default is 3.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
+
+        Returns
+        -------
+        dict
+            A dictionary of similarity scores between 0 (completely dissimilar) and 1 (identical), based on weighted components.
+            The keys in the dictionary are:
+            "attribute"
+            "geometry"
+            "metrics"
+            "structure"
+            "wl"
+            "overall"
+
+        """
+        
+        import hashlib
+        from collections import Counter
+        from topologicpy.Graph import Graph
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Topology import Topology
+        from topologicpy.Dictionary import Dictionary
+
+        def attribute_similarity(graphA, graphB, mantissa=6):
+            v1 = Graph.Vertices(graphA)
+            v2 = Graph.Vertices(graphB)
+            if len(v1) != len(v2) or len(v1) == 0:
+                return 0
+
+            match_score = 0
+            for a, b in zip(v1, v2):
+                dict_a = Topology.Dictionary(a)
+                dict_b = Topology.Dictionary(b)
+
+                keys_a = set(Dictionary.Keys(dict_a)) if dict_a else set()
+                keys_b = set(Dictionary.Keys(dict_b)) if dict_b else set()
+
+                if not keys_a and not keys_b:
+                    match_score += 1
+                else:
+                    intersection = len(keys_a & keys_b)
+                    union = len(keys_a | keys_b)
+                    match_score += intersection / union if union > 0 else 0
+
+            return round(match_score / len(v1), mantissa)
+        
+        def geometry_similarity(graphA, graphB, mantissa=6):
+            v1 = Graph.Vertices(graphA)
+            v2 = Graph.Vertices(graphB)
+            if len(v1) != len(v2) or len(v1) == 0:
+                return 0
+
+            total_dist = 0
+            for a, b in zip(v1, v2):  # assumes same order
+                p1 = Vertex.Coordinates(a, mantissa=mantissa)
+                p2 = Vertex.Coordinates(b, mantissa=mantissa)
+                total_dist += sum((i - j) ** 2 for i, j in zip(p1, p2)) ** 0.5
+            avg_dist = total_dist / len(v1)
+            return round(1 / (1 + avg_dist), mantissa) # Inverse average distance
+        
+        def metrics_similarity(graphA, graphB, mantissa=6):
+            # Example using global metrics + mean of node metrics
+            def safe_mean(lst):
+                return sum(lst)/len(lst) if lst else 0
+
+            metrics1 = {
+                "closeness": safe_mean(Graph.ClosenessCentrality(graphA)),
+                "betweenness": safe_mean(Graph.BetweennessCentrality(graphA)),
+                "degree": safe_mean(Graph.DegreeCentrality(graphA)),
+                "pagerank": safe_mean(Graph.PageRank(graphA)),
+                "clustering": Graph.GlobalClusteringCoefficient(graphA),
+                "diameter": Graph.Diameter(graphA)
+            }
+
+            metrics2 = {
+                "closeness": safe_mean(Graph.ClosenessCentrality(graphB)),
+                "betweenness": safe_mean(Graph.BetweennessCentrality(graphB)),
+                "degree": safe_mean(Graph.DegreeCentrality(graphB)),
+                "pagerank": safe_mean(Graph.PageRank(graphB)),
+                "clustering": Graph.GlobalClusteringCoefficient(graphB),
+                "diameter": Graph.Diameter(graphB)
+            }
+
+            # Compute similarity as 1 - normalized absolute difference
+            similarities = []
+            for key in metrics1:
+                v1, v2 = metrics1[key], metrics2[key]
+                if v1 == 0 and v2 == 0:
+                    similarities.append(1)
+                else:
+                    diff = abs(v1 - v2) / max(abs(v1), abs(v2), 1e-6)
+                    similarities.append(1 - diff)
+
+            return round(sum(similarities) / len(similarities), mantissa)
+        
+        def structure_similarity(graphA, graphB, mantissa=6):
+            v1 = Graph.Vertices(graphA)
+            v2 = Graph.Vertices(graphB)
+            e1 = Graph.Edges(graphA)
+            e2 = Graph.Edges(graphB)
+
+            vertex_score = 1 - abs(len(v1) - len(v2)) / max(len(v1), len(v2), 1)
+            edge_score = 1 - abs(len(e1) - len(e2)) / max(len(e1), len(e2), 1)
+
+            return round((vertex_score + edge_score) / 2, mantissa)
+
+        def weisfeiler_lehman_fingerprint(graph, iterations=3):
+            vertices = Graph.Vertices(graph)
+            labels = {}
+
+            for v in vertices:
+                d = Topology.Dictionary(v)
+                label = str(Dictionary.ValueAtKey(d, "label")) if d and Dictionary.ValueAtKey(d, "label") else "0"
+                labels[v] = label
+
+            all_label_counts = Counter()
+
+            for _ in range(iterations):
+                new_labels = {}
+                for v in vertices:
+                    neighbors = Graph.AdjacentVertices(graph, v)
+                    neighbor_labels = sorted(labels.get(n, "0") for n in neighbors)
+                    long_label = labels[v] + "_" + "_".join(neighbor_labels)
+                    hashed_label = hashlib.md5(long_label.encode()).hexdigest()
+                    new_labels[v] = hashed_label
+                    all_label_counts[hashed_label] += 1
+                labels = new_labels
+
+            return all_label_counts
+
+        def weisfeiler_lehman_similarity(graphA, graphB, iterations=3, mantissa=6):
+            f1 = weisfeiler_lehman_fingerprint(graphA, iterations)
+            f2 = weisfeiler_lehman_fingerprint(graphB, iterations)
+
+            common_labels = set(f1.keys()) & set(f2.keys())
+            score = sum(min(f1[label], f2[label]) for label in common_labels)
+            norm = max(sum(f1.values()), sum(f2.values()), 1)
+
+            return round(score / norm, mantissa)
+        
+        if not Topology.IsInstance(graphA, "graph"):
+            if not silent:
+                print("Graph.Compare - Error: The graphA input parameter is not a valid topologic graph. Returning None.")
+            return None
+        if not Topology.IsInstance(graphB, "graph"):
+            if not silent:
+                print("Graph.Compare - Error: The graphB input parameter is not a valid topologic graph. Returning None.")
+            return 
+        
+        total_weight = weightAttributes + weightGeometry + weightMetrics + weightStructure + weightWL
+
+        attribute_score = attribute_similarity(graphA, graphB, mantissa=mantissa) if weightAttributes else 0
+        geometry_score = geometry_similarity(graphA, graphB, mantissa=mantissa) if weightGeometry else 0
+        metrics_score = metrics_similarity(graphA, graphB, mantissa=mantissa) if weightMetrics else 0
+        structure_score = structure_similarity(graphA, graphB, mantissa=mantissa) if weightStructure else 0
+        wl_score = weisfeiler_lehman_similarity(graphA, graphB, iterations, mantissa=mantissa) if weightWL else 0
+
+        weighted_sum = (
+            attribute_score * weightAttributes +
+            geometry_score * weightGeometry +
+            metrics_score * weightMetrics +
+            structure_score * weightStructure +
+            wl_score * weightWL
+        )
+
+        if total_weight <= 0:
+            overall_score = 0
+        else:
+            overall_score = weighted_sum / total_weight
+        
+        return  { "attribute": round(attribute_score, mantissa),
+                "geometry": round(geometry_score, mantissa),
+                "metrics": round(metrics_score, mantissa),
+                "structure": round(structure_score, mantissa),
+                "wl": round(wl_score, mantissa),
+                "overall": round(overall_score, mantissa)
+                }
+
     @staticmethod
     def Complement(graph, tolerance=0.0001, silent=False):
         """
@@ -8850,7 +9064,7 @@ class Graph:
         return max_flow
 
     @staticmethod
-    def MeshData(graph, tolerance: float = 0.0001):
+    def MeshData(graph, mantissa: int = 6, tolerance: float = 0.0001):
         """
         Returns the mesh data of the input graph.
 
@@ -8858,6 +9072,8 @@ class Graph:
         ----------
         graph : topologic_core.Graph
             The input graph.
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
 
@@ -8880,7 +9096,7 @@ class Graph:
         m_vertices = []
         v_dicts = []
         for g_vertex in g_vertices:
-            m_vertices.append(Vertex.Coordinates(g_vertex))
+            m_vertices.append(Vertex.Coordinates(g_vertex, mantissa=mantissa))
             d = Dictionary.PythonDictionary(Topology.Dictionary(g_vertex))
             v_dicts.append(d)
         g_edges = Graph.Edges(graph)
@@ -9778,6 +9994,31 @@ class Graph:
         _ = graph.RemoveEdges([edge], tolerance) # Hook to Core
         return graph
     
+    @staticmethod
+    def RemoveIsolatedVertices(graph, tolerance=0.0001):
+        """
+        Removes all isolated vertices from the input graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        topologic_core.Graph
+            The input graph with all isolated vertices removed.
+
+        """
+        from topologicpy.Topology import Topology
+
+        vertices = Graph.Vertices(graph)
+        edges = Graph.Edges(graph)
+        vertices = [v for v in vertices if Graph.VertexDegree(graph, v) > 0]
+        return Graph.ByVerticesEdges(vertices, edges)
+
     @staticmethod
     def RemoveVertex(graph, vertex, tolerance=0.0001):
         """
@@ -10299,6 +10540,125 @@ class Graph:
                 v = Topology.SetDictionary(v, d)
         return return_graph
 
+    @staticmethod
+    def SubGraphMatches(subGraph, superGraph, strict=False, vertexMatcher=None, vertexKey: str = "id", mantissa: int = 6, tolerance: float = 0.0001):
+        """
+        Finds all subgraph matches from `subgraph` into `supergraph`.
+        A match is valid if:
+        - Each subgraph vertex maps to a unique supergraph vertex either by the vertexMatcher function or through matching the vertexKey values.
+        - Each subgraph edge is represented either by an edge (if strict is set to True) or by an edge or a path (if strict is set to False) in the supergraph.
+
+        Parameters
+        ----------
+        subGraph : topologic_core.Graph
+            The input subgraph.
+        superGraph : topologic_core.Graph
+            The input supergraph.
+        strict : bool , optional
+            If set to True, each subgraph edge must be represented by a single edge in the supergraph. Otherwise, an edge in the subgraph can be represented either with an edge or a path in the supergraph. The default is False.
+        vertexMatcher : callable, optional
+            If specified, this function is called to check if two vertices are matched. The format must be vertex_matcher(sub_vertex, super_vertex, mantissa, tolerance) -> bool.
+        vertexKey : str , optional
+            The dictionary key to use for vertex matching if the vertexMatcher input parameter is set to None. The default is "id".
+        mantissa : int , optional
+            The desired length of the mantissa. The default is 6.
+        tolerance : float , optional
+            The desired tolerance. The default is 0.0001.
+
+        Returns
+        -------
+        list
+            A list of subgraphs matched to the supergraph. Each vertex in the matched subgraph has a dictionary that merges the keys and values from both the subgraph and the supergraph. 
+        """
+
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Edge import Edge
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Topology import Topology
+        import itertools
+
+        sub_vertices = Graph.Vertices(subGraph)
+        super_vertices = Graph.Vertices(superGraph)
+
+        sub_ids = [Dictionary.ValueAtKey(Topology.Dictionary(v), vertexKey) for v in sub_vertices]
+
+        # Map vertex instance to index in sub_vertices
+        sub_vertex_indices = {vid: i for i, vid in enumerate(sub_ids)}
+
+        # Default matcher by dictionary vertexKey
+        if vertexMatcher is None:
+            def vertexMatcher(v1, v2, mantissa=mantissa, tolerance=tolerance):
+                d1 = Topology.Dictionary(v1)
+                d2 = Topology.Dictionary(v2)
+                id1 = Dictionary.ValueAtKey(d1, vertexKey) if d1 else None
+                id2 = Dictionary.ValueAtKey(d2, vertexKey) if d2 else None
+                return id1 == id2 and id1 is not None
+
+        # Step 1: Build candidate list for each subgraph vertex (by index)
+        candidate_map = {}
+        for i, sv in enumerate(sub_vertices):
+            candidates = [v for v in super_vertices if vertexMatcher(sv, v, mantissa=mantissa, tolerance=tolerance)]
+            if not candidates:
+                return []  # No match for this vertex
+            candidate_map[i] = candidates
+
+        # Step 2: Generate all injective mappings
+        all_matches = []
+        sub_indices = list(candidate_map.keys())
+        candidate_lists = [candidate_map[i] for i in sub_indices]
+
+        for combo in itertools.product(*candidate_lists):
+            if len(set(combo)) < len(combo):
+                continue  # Not injective
+
+            mapping = dict(zip(sub_indices, combo))
+
+            # Step 3: Check that each subgraph edge corresponds to a path in supergraph
+            valid = True
+            for edge in Graph.Edges(subGraph):
+                sv1 = Edge.StartVertex(edge)
+                sv2 = Edge.EndVertex(edge)
+                d1 = Topology.Dictionary(sv1)
+                d2 = Topology.Dictionary(sv2)
+                id1 = Dictionary.ValueAtKey(d1, vertexKey) if d1 else None
+                id2 = Dictionary.ValueAtKey(d2, vertexKey) if d2 else None
+                if id1 == None or id2 == None:
+                    continue
+                else:
+                    i1 = sub_vertex_indices[id1]
+                    i2 = sub_vertex_indices[id2]
+                    gv1 = mapping[i1]
+                    gv2 = mapping[i2]
+
+                    path = Graph.ShortestPath(superGraph, gv1, gv2)
+                    if not path:
+                        valid = False
+                        break
+                    elif strict:
+                        if Topology.IsInstance(path, "Wire"):
+                            if len(Topology.Edges(path)) > 1:
+                                valid = False
+                                break
+
+            if valid:
+                all_matches.append(mapping)
+
+        matched_subgraphs = []
+        if len(all_matches) > 0:
+            vertex_dictionaries = []
+            d = Graph.MeshData(subGraph)
+            subgraph_edges = d['edges']
+            edge_dictionaries = d['edgeDictionaries']
+            positions = []
+            for i, mapping in enumerate(all_matches, 1):
+                for svid, gv in mapping.items():
+                    positions.append(Vertex.Coordinates(gv))
+                    sd = Topology.Dictionary(sub_vertices[svid])
+                    gd = Topology.Dictionary(gv)
+                    vertex_dictionaries.append(Dictionary.ByMergedDictionaries(sd, gd))
+                matched_subgraphs.append(Graph.ByMeshData(positions, subgraph_edges, vertexDictionaries=vertex_dictionaries, edgeDictionaries=edge_dictionaries))
+        return matched_subgraphs
+
     @staticmethod
     def _topological_distance(g, start, target):
         from collections import deque

topologicpy/Plotly.py

@@ -282,6 +282,10 @@ class Plotly:
                     vertexSize: float = 10,
                     vertexSizeKey: str = None,
                     vertexLabelKey: str = None,
+                    vertexBorderColor: str = "black",
+                    vertexBorderWidth: float = 1,
+                    vertexBorderColorKey: str = None,
+                    vertexBorderWidthKey: float = None,
                     vertexGroupKey: str = None,
                     vertexGroups: list = [],
                     vertexMinGroup = None,
@@ -422,6 +426,10 @@ class Plotly:
                                    colorKey=vertexColorKey,
                                    size=vertexSize,
                                    sizeKey=vertexSizeKey,
+                                   borderColor=vertexBorderColor,
+                                   borderWidth=vertexBorderWidth,
+                                   borderColorKey=vertexBorderColorKey,
+                                   borderWidthKey=vertexBorderWidthKey,
                                    labelKey=vertexLabelKey,
                                    showVertexLabel=showVertexLabel,
                                    groupKey=vertexGroupKey,
@@ -433,24 +441,7 @@ class Plotly:
                                    legendRank=vertexLegendRank,
                                    showLegend=showVertexLegend,
                                    colorScale=colorScale)
-
-                # v_data = Plotly.DataByTopology(e_cluster,
-                #                         vertexColor=vertexColor,
-                #                         vertexColorKey=vertexColorKey,
-                #                         vertexSize=vertexSize,
-                #                         vertexSizeKey=vertexSizeKey,
-                #                         vertexLabelKey=vertexLabelKey,
-                #                         showVertexLabel=showVertexLabel,
-                #                         vertexGroupKey=vertexGroupKey,
-                #                         vertexMinGroup=vertexMinGroup,
-                #                         vertexMaxGroup=vertexMaxGroup,
-                #                         vertexGroups=vertexGroups,
-                #                         showVertexLegend=showVertexLegend,
-                #                         vertexLegendLabel=vertexLegendLabel,
-                #                         vertexLegendGroup=vertexLegendGroup,
-                #                         vertexLegendRank=vertexLegendRank,
-                #                         colorScale=colorScale)
-                data += [v_data]
+                data += v_data
         
         if showEdges:
             e_dictionaries = []
@@ -486,17 +477,45 @@ class Plotly:
         return data
     
     @staticmethod
-    def vertexData(vertices, dictionaries=[], color="black", colorKey=None, size=1.1, sizeKey=None, labelKey=None, showVertexLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Vertices", legendGroup=1, legendRank=1, showLegend=True, colorScale="Viridis"):
+    def vertexData(vertices,
+                   dictionaries=[],
+                   color="black",
+                   colorKey=None,
+                   size=1.1,
+                   sizeKey=None,
+                   borderColor="black",
+                   borderWidth=0,
+                   borderColorKey=None,
+                   borderWidthKey=None,
+                   labelKey=None,
+                   showVertexLabel = False,
+                   groupKey=None,
+                   minGroup=None,
+                   maxGroup=None,
+                   groups=[],
+                   legendLabel="Topology Vertices",
+                   legendGroup=1,
+                   legendRank=1,
+                   showLegend=True,
+                   colorScale="Viridis"):
         from topologicpy.Dictionary import Dictionary
         from topologicpy.Color import Color
         x = []
         y = []
         z = []
         n = len(str(len(vertices)))
-        sizes = [size for i in range(len(vertices))]
-        labels = ["Vertex_"+str(i+1).zfill(n) for i in range(len(vertices))]
-        colors = [Color.AnyToHex(color) for i in range(len(vertices))]
-        if colorKey or sizeKey or labelKey or groupKey:
+        sizes = []
+        labels = []
+        colors = []
+        borderColors = []
+        borderSizes = []
+        for i in range(len(vertices)):
+            sizes.append(size)
+            labels.append("Vertex_"+str(i+1).zfill(n))
+            colors.append(Color.AnyToHex(color))
+            borderColors.append(borderColor)
+            borderSizes.append(size+borderWidth*2)
+        if colorKey or sizeKey or borderColorKey or borderWidthKey or labelKey or groupKey:
             if groups:
                 if len(groups) > 0:
                     if type(groups[0]) == int or type(groups[0]) == float:
@@ -515,10 +534,8 @@ class Plotly:
                 x.append(v[0])
                 y.append(v[1])
                 z.append(v[2])
-                #colors.append(Color.AnyToHex(color))
-                #labels.append("Vertex_"+str(m+1).zfill(n))
-                #sizes.append(max(size, 1.1))
                 if len(dictionaries) > 0:
+
                     d = dictionaries[m]
                     if d:
                         if not colorKey == None:
@@ -533,6 +550,16 @@ class Plotly:
                                sizes[m] = size
                             if sizes[m] <= 0:
                                 sizes[m] = 1.1
+                        if not borderColorKey == None:
+                            temp_color = Dictionary.ValueAtKey(d, key=borderColorKey)
+                            if not temp_color == None:
+                                borderColors[m] = Color.AnyToHex(temp_color)
+                        if not borderWidthKey == None:
+                            temp_width = Dictionary.ValueAtKey(d, key=borderWidthKey)
+                            if temp_width == None or temp_width <= 0:
+                               borderSizes[m] = 0
+                            else:
+                                borderSizes[m] = sizes[m] + temp_width*2
                         if not groupKey == None:
                             c_value = Dictionary.ValueAtKey(d, key=groupKey)
                             if not c_value == None:
@@ -565,14 +592,16 @@ class Plotly:
             mode = "markers+text"
         else:
             mode = "markers"
-        vData= go.Scatter3d(x=x,
+        vData2 = go.Scatter3d(x=x,
                             y=y,
                             z=z,
                             name=legendLabel,
                             showlegend=showLegend,
                             marker=dict(color=colors,
-                                        size=sizes, 
-                                        opacity=1),
+                                        size=sizes,
+                                        symbol="circle", 
+                                        opacity=1,
+                                        sizemode="diameter"),
                             mode=mode,
                             legendgroup=legendGroup,
                             legendrank=legendRank,
@@ -580,7 +609,24 @@ class Plotly:
                             hoverinfo='text',
                             hovertext=labels
                             )
-        return vData
+        if borderWidth > 0 or borderWidthKey:
+            vData1 = go.Scatter3d(x=x,
+                                y=y,
+                                z=z,
+                                name=legendLabel,
+                                showlegend=showLegend,
+                                marker=dict(color=borderColors,
+                                            size=borderSizes,
+                                            symbol="circle", 
+                                            opacity=1,
+                                            sizemode="diameter"),
+                                mode=mode
+                                )
+            
+            return_value = [vData1]+[vData2]
+        else:
+            return_value = [vData2]
+        return return_value
 
     @staticmethod
     def edgeData(vertices, edges, dictionaries=None, color="black", colorKey=None, width=1, widthKey=None, labelKey=None, showEdgeLabel = False, groupKey=None, minGroup=None, maxGroup=None, groups=[], legendLabel="Topology Edges", legendGroup=2, legendRank=2, showLegend=True, colorScale="Viridis"):
@@ -716,11 +762,15 @@ class Plotly:
     @staticmethod
     def DataByTopology(topology,
                        showVertices=True,
-                       vertexSize=1.1,
+                       vertexSize=2.8,
                        vertexSizeKey=None,
                        vertexColor="black",
                        vertexColorKey=None,
                        vertexLabelKey=None,
+                       vertexBorderColor: str = "black",
+                       vertexBorderWidth: float = 0,
+                       vertexBorderColorKey: str = None,
+                       vertexBorderWidthKey: float = None,
                        showVertexLabel=False,
                        vertexGroupKey=None,
                        vertexGroups=[], 
@@ -771,7 +821,7 @@ class Plotly:
         showVertices : bool , optional
             If set to True the vertices will be drawn. Otherwise, they will not be drawn. The default is True.
         vertexSize : float , optional
-            The desired size of the vertices. The default is 1.1.
+            The desired size of the output vertices. The default is 1.1.
         vertexSizeKey : str , optional
             The dictionary key under which to find the vertex size.The default is None.
         vertexColor : str , optional
@@ -784,6 +834,16 @@ class Plotly:
             The default is "black".
         vertexColorKey : str , optional
             The dictionary key under which to find the vertex color.The default is None.
+        vertexBorderWidth : float , optional
+            The desired width of the border of the output vertices. The default is 1.
+        vertexBorderColor : str , optional
+            The desired color of the border of the output vertices. This can be any plotly color string and may be specified as:
+            - A hex string (e.g. '#ff0000')
+            - An rgb/rgba string (e.g. 'rgb(255,0,0)')
+            - An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
+            - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
+            - A named CSS color.
+            The default is "black".
         vertexLabelKey : str , optional
             The dictionary key to use to display the vertex label. The default is None.
         vertexGroupKey : str , optional
@@ -1066,11 +1126,31 @@ class Plotly:
             if showVertices:
                 if len(vertices) == 0:
                     for i, tp_v in enumerate(tp_vertices):
-                        if vertexColorKey or vertexSizeKey or vertexLabelKey or vertexGroupKey:
+                        if vertexColorKey or vertexSizeKey or vertexBorderColorKey or vertexBorderWidthKey or vertexLabelKey or vertexGroupKey:
                             d = Topology.Dictionary(tp_v)
                             v_dictionaries.append(d)
                         vertices.append([Vertex.X(tp_v, mantissa=mantissa), Vertex.Y(tp_v, mantissa=mantissa), Vertex.Z(tp_v, mantissa=mantissa)])
-                data.append(Plotly.vertexData(vertices, dictionaries=v_dictionaries, color=vertexColor, colorKey=vertexColorKey, size=vertexSize, sizeKey=vertexSizeKey, labelKey=vertexLabelKey, showVertexLabel=showVertexLabel, groupKey=vertexGroupKey, minGroup=vertexMinGroup, maxGroup=vertexMaxGroup, groups=vertexGroups, legendLabel=vertexLegendLabel, legendGroup=vertexLegendGroup, legendRank=vertexLegendRank, showLegend=showVertexLegend, colorScale=colorScale))
+                data.extend(Plotly.vertexData(vertices,
+                                              dictionaries=v_dictionaries,
+                                              color=vertexColor,
+                                              colorKey=vertexColorKey,
+                                              size=vertexSize,
+                                              sizeKey=vertexSizeKey,
+                                              borderColor=vertexBorderColor,
+                                              borderWidth=vertexBorderWidth,
+                                              borderColorKey=vertexBorderColorKey,
+                                              borderWidthKey=vertexBorderWidthKey,
+                                              labelKey=vertexLabelKey,
+                                              showVertexLabel=showVertexLabel,
+                                              groupKey=vertexGroupKey,
+                                              minGroup=vertexMinGroup,
+                                              maxGroup=vertexMaxGroup,
+                                              groups=vertexGroups,
+                                              legendLabel=vertexLegendLabel,
+                                              legendGroup=vertexLegendGroup,
+                                              legendRank=vertexLegendRank,
+                                              showLegend=showVertexLegend,
+                                              colorScale=colorScale))
             
         if showEdges and Topology.Type(topology) > Topology.TypeID("Vertex"):
             if Topology.Type(topology) == Topology.TypeID("Edge"):

topologicpy/Topology.py

@@ -8500,10 +8500,14 @@ class Topology():
              nameKey = "name",
              opacityKey = "opacity",
              showVertices=True,
-             vertexSize=None,
+             vertexSize=2.8,
              vertexSizeKey = None,
              vertexColor="black",
              vertexColorKey = None,
+             vertexBorderWidth=0,
+             vertexBorderColor="black",
+             vertexBorderWidthKey=None,
+             vertexBorderColorKey=None,
              vertexLabelKey=None,
              showVertexLabel= False,
              vertexGroupKey=None,
@@ -8602,6 +8606,16 @@ class Topology():
             The default is "black".
         vertexColorKey : str , optional
             The key under which to find the color of the vertex. The default is None.
+        vertexBorderWidth : float , optional
+            The desired width of the borders of the output vertices. The default is 0.
+        vertexBorderColor : str , optional
+            The desired color of the borders of the output vertices. This can be any plotly color string and may be specified as:
+            - A hex string (e.g. '#ff0000')
+            - An rgb/rgba string (e.g. 'rgb(255,0,0)')
+            - An hsl/hsla string (e.g. 'hsl(0,100%,50%)')
+            - An hsv/hsva string (e.g. 'hsv(0,100%,100%)')
+            - A named CSS color.
+            The default is "black".
         vertexLabelKey : str , optional
             The dictionary key to use to display the vertex label. The default is None.
         showVertexLabels : bool , optional
@@ -8798,7 +8812,7 @@ class Topology():
                 vll = name+" ("+vertexLegendLabel+")"
                 ell = name+" ("+edgeLegendLabel+")"
                 
-                data += Plotly.DataByGraph(topology,
+                data.extend(Plotly.DataByGraph(topology,
                                            sagitta=sagitta,
                                            absolute=absolute,
                                            sides=sides,
@@ -8807,6 +8821,10 @@ class Topology():
                                            vertexColorKey=vertexColorKey,
                                            vertexSize=vSize,
                                            vertexSizeKey=vertexSizeKey,
+                                           vertexBorderColor= vertexBorderColor,
+                                           vertexBorderWidth=vertexBorderWidth,
+                                           vertexBorderColorKey= vertexBorderColorKey,
+                                           vertexBorderWidthKey=vertexBorderWidthKey,
                                            vertexLabelKey=vertexLabelKey,
                                            vertexGroupKey=vertexGroupKey,
                                            vertexGroups=vertexGroups,
@@ -8834,7 +8852,7 @@ class Topology():
                                            edgeLegendRank= (graph_counter+2),
                                            edgeLegendGroup=(graph_counter+2),
                                            colorScale=colorScale,
-                                           silent=silent)
+                                           silent=silent))
                 graph_counter += offset
             else:
                 name = Dictionary.ValueAtKey(d, nameKey) or "Untitled"
@@ -8852,12 +8870,16 @@ class Topology():
                     eColor = edgeColor
                 if not d == None:
                     faceOpacity = Dictionary.ValueAtKey(d, opacityKey) or faceOpacity
-                data += Plotly.DataByTopology(topology=topology,
+                data.extend(Plotly.DataByTopology(topology=topology,
                                               showVertices=showVertices,
                                               vertexSize=vSize,
                                               vertexSizeKey=vertexSizeKey,
                                               vertexColor=vertexColor,
                                               vertexColorKey=vertexColorKey,
+                                              vertexBorderWidth=vertexBorderWidth,
+                                              vertexBorderColor=vertexBorderColor,
+                                              vertexBorderColorKey= vertexBorderColorKey,
+                                              vertexBorderWidthKey=vertexBorderWidthKey,
                                               vertexLabelKey=vertexLabelKey,
                                               showVertexLabel=showVertexLabel,
                                               vertexGroupKey=vertexGroupKey,
@@ -8901,7 +8923,7 @@ class Topology():
                                               intensities=intensities,
                                               colorScale=colorScale,
                                               mantissa=mantissa,
-                                              tolerance=tolerance)
+                                              tolerance=tolerance))
                 topology_counter += offset
         figure = Plotly.FigureByData(data=data, width=width, height=height,
                                      xAxis=xAxis, yAxis=yAxis, zAxis=zAxis, axisSize=axisSize,

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.18'
+__version__ = '0.8.20'

{topologicpy-0.8.18.dist-info → topologicpy-0.8.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: topologicpy
-Version: 0.8.18
+Version: 0.8.20
 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
@@ -40,6 +40,7 @@ Requires-Dist: webcolors
 Requires-Dist: topologic_core>=7.0.1
 Provides-Extra: test
 Requires-Dist: pytest-xdist>=2.4.0; extra == "test"
+Dynamic: license-file
 
 # topologicpy
 

{topologicpy-0.8.18.dist-info → topologicpy-0.8.20.dist-info}/RECORD

@@ -11,26 +11,26 @@ topologicpy/Dictionary.py,sha256=7h-Gszgnt2OEOvOSADJ4pa-mTNlhQ9cuIiB5WHEW6aY,339
 topologicpy/Edge.py,sha256=yxkCVDYBflJNEYxnjMmlyvbkpg8TNy7y5bSH3yQ4jzs,71418
 topologicpy/EnergyModel.py,sha256=UoQ9Jm-hYsN383CbcLKw-y6BKitRHj0uyh84yQ-8ACg,53856
 topologicpy/Face.py,sha256=SlhB8L7BpDjd4a9YZE4UJ3zoGuF1oq9MSpuesEWro_Q,184847
-topologicpy/Graph.py,sha256=FBmiMObzztPwZFJ2T846Ivz0Y1kpzMF0sF-PDUMPk4o,498946
+topologicpy/Graph.py,sha256=fsWgbYp1di1HtDipsXY9d2i42Fn_3dXsVKTac9vl7bU,515137
 topologicpy/Grid.py,sha256=2s9cSlWldivn1i9EUz4OOokJyANveqmRe_vR93CAndI,18245
 topologicpy/Helper.py,sha256=4H5KPiv_eiEs489UOOyGLe9RaeoZIfmMh3mk_YCHmXg,29100
 topologicpy/Honeybee.py,sha256=uDVtDbloydNoaBFcSNukKL_2PLyD6XKkCp1VHz1jtaU,21751
 topologicpy/Matrix.py,sha256=i22RLP5ebUAMuU7V1tZ__Z4lf1pg9fzq9nENsDZUV74,22779
 topologicpy/Neo4j.py,sha256=BKOF29fRgXmdpMGkrNzuYbyqgCJ6ElPPMYlfTxXiVbc,22392
-topologicpy/Plotly.py,sha256=RU_VioIRLGIYzwyKI9OQHOx9OxxGppdpagysgTbdxIE,115942
+topologicpy/Plotly.py,sha256=gSe3tWLgF75-rPDjqw7riUIJpv0j_K7hedoxi3-OptE,119244
 topologicpy/Polyskel.py,sha256=ro5in--VT_uag55r5xymU5ufyAahsovIiJwyiqG_qH8,27082
 topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=--dJoSdz6BapxVEyG2DI0W5apO_xwLORj5qmR15yl2Y,87983
 topologicpy/Speckle.py,sha256=AlsGlSDuKRtX5jhVsPNSSjjbZis079HbUchDH_5RJmE,18187
 topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
-topologicpy/Topology.py,sha256=GFoSWeI5lwF1Uv2zQwZ6nZcs62YzdBAgI0HL1Lvq-NU,477015
+topologicpy/Topology.py,sha256=QY195KZ5EostlGRnsPGSFglRIU0tunD2CiwsFPfpOqY,478447
 topologicpy/Vector.py,sha256=GkGt-aJ591IJ2IPffMAudvITLDPi2qZibZc4UAav6m8,42407
 topologicpy/Vertex.py,sha256=q99IrWwdNlvVfUXz6iP8icmP8NzP2nsiqtgnF9Jnpx8,80913
 topologicpy/Wire.py,sha256=IVPzBKsckuxC-rHvwxmvtVF7PpApz2lhPHomtQMo_kg,228499
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=vkzceT3rP0TlvJzcK0aNKq2TjD8ttqpbJun23OGEYQs,23
-topologicpy-0.8.18.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.18.dist-info/METADATA,sha256=Vl4wrRYKrz-K7io5ohz_sWZScxQf1MXQXR-I2x79ie0,10513
-topologicpy-0.8.18.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-topologicpy-0.8.18.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.18.dist-info/RECORD,,
+topologicpy/version.py,sha256=uWqZIJblLUrle0kYZkrKO4aVSNXiyYenL0G_TSUJllE,23
+topologicpy-0.8.20.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.20.dist-info/METADATA,sha256=0_3vo7ubfFiV0woZaJt8RCFHF9MZZ_Sc7VnqYZX4Mao,10535
+topologicpy-0.8.20.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+topologicpy-0.8.20.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.20.dist-info/RECORD,,

{topologicpy-0.8.18.dist-info → topologicpy-0.8.20.dist-info}/WHEEL

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