topologicpy 0.8.51__py3-none-any.whl → 0.8.54__py3-none-any.whl

topologicpy/Cell.py

@@ -1552,7 +1552,6 @@ class Cell():
         cluster = Cluster.ByTopologies(pentagons)
         
         cluster2 = Topology.Rotate(cluster, origin=Vertex.Origin(), axis=[1, 0, 0], angle=180)
-        #cluster2 = Topology.Rotate(cluster2, origin=Vertex.Origin(), axis=[0, 0, 1], angle=36)
         vertices = Topology.Vertices(cluster)
         zList = [Vertex.Z(v) for v in vertices]
         zList = list(set(zList))
@@ -1566,6 +1565,7 @@ class Cell():
         dodecahedron = Topology.Translate(dodecahedron, -Vertex.X(centroid), -Vertex.Y(centroid), -Vertex.Z(centroid))
         vertices = Topology.Vertices(dodecahedron)
         d = Vertex.Distance(Vertex.Origin(), vertices[0])
+        # Make sure the distance from the origin to the vertices is equal to the radius.
         dodecahedron = Topology.Scale(dodecahedron, origin=Vertex.Origin(), x=radius/d, y=radius/d, z=radius/d)
         if placement == "bottom":
             dodecahedron = Topology.Translate(dodecahedron, 0, 0, radius)
@@ -3091,9 +3091,9 @@ class Cell():
     
     @staticmethod
     def Sphere(origin= None, radius: float = 0.5, uSides: int = 16, vSides: int = 8, direction: list = [0, 0, 1],
-                   placement: str = "center", tolerance: float = 0.0001):
+                   placement: str = "center", tolerance: float = 0.0001, silent: bool = False):
         """
-        Creates a sphere.
+        Creates an approximation of a sphere using a UV grid of triangular faces.
 
         Parameters
         ----------
@@ -3111,6 +3111,9 @@ class Cell():
             The description of the placement of the origin of the sphere. This can be "bottom", "center", or "lowerleft". It is case insensitive. Default is "center".
         tolerance : float , optional
             The desired tolerance. Default is 0.0001.
+        silent : bool, optional
+            If set to True, suppresses warning and error messages. Default is False.
+        
 
         Returns
         -------
@@ -3118,24 +3121,89 @@ class Cell():
             The created sphere.
 
         """
-
+    
+        import math
         from topologicpy.Vertex import Vertex
-        from topologicpy.Wire import Wire
-        from topologicpy.CellComplex import CellComplex
+        from topologicpy.Face import Face
+        from topologicpy.Cell import Cell
         from topologicpy.Topology import Topology
 
-        if not Topology.IsInstance(origin, "Vertex"):
+        # Validate inputs
+        if radius <= 0 or uSides < 3 or vSides < 2:
+            if not silent:
+                print("Sphere - Error: radius must be > 0, uSides >= 3, vSides >= 2. Returning None.")
+            return None
+
+        # Center
+        if origin is None:
             origin = Vertex.ByCoordinates(0, 0, 0)
-        if not Topology.IsInstance(origin, "Vertex"):
-            print("Cell.Sphere - Error: The input origin parameter is not a valid topologic vertex. Returning None.")
+        ox = Vertex.X(origin)
+        oy = Vertex.Y(origin)
+        oz = Vertex.Z(origin)
+
+        # Poles
+        top_pole = Vertex.ByCoordinates(ox, oy, oz + radius)
+        bottom_pole = Vertex.ByCoordinates(ox, oy, oz - radius)
+
+        # Latitude rings (exclude poles)
+        rings = []  # list of list[Vertex]
+        for vi in range(1, vSides):
+            phi = math.pi * vi / vSides  # 0..pi
+            sin_phi = math.sin(phi)
+            cos_phi = math.cos(phi)
+            ring = []
+            for ui in range(uSides):
+                theta = 2.0 * math.pi * ui / uSides
+                x = ox + radius * sin_phi * math.cos(theta)
+                y = oy + radius * sin_phi * math.sin(theta)
+                z = oz + radius * cos_phi
+                ring.append(Vertex.ByCoordinates(x, y, z))
+            rings.append(ring)
+
+        faces = []
+
+        # Top cap: triangles from top pole to first ring
+        first_ring = rings[0]
+        for u in range(uSides):
+            v1 = first_ring[u]
+            v2 = first_ring[(u + 1) % uSides]
+            f = Face.ByVertices([top_pole, v1, v2], tolerance=tolerance)
+            if f:
+                faces.append(f)
+
+        # Middle bands: split quads into two triangles
+        for i in range(len(rings) - 1):
+            curr = rings[i]
+            nxt = rings[i + 1]
+            for u in range(uSides):
+                a = curr[u]
+                b = nxt[u]
+                c = nxt[(u + 1) % uSides]
+                d = curr[(u + 1) % uSides]
+                f1 = Face.ByVertices([a, b, c], tolerance=tolerance)
+                if f1:
+                    faces.append(f1)
+                f2 = Face.ByVertices([a, c, d], tolerance=tolerance)
+                if f2:
+                    faces.append(f2)
+
+        # Bottom cap: triangles from last ring to bottom pole
+        last_ring = rings[-1]
+        for u in range(uSides):
+            v1 = last_ring[(u + 1) % uSides]
+            v2 = last_ring[u]
+            f = Face.ByVertices([bottom_pole, v1, v2], tolerance=tolerance)
+            if f:
+                faces.append(f)
+
+        # Sew faces into a shell
+        sphere = None
+        try:
+            sphere = Cell.ByFaces(faces, tolerance=tolerance)
+        except Exception:
+            if not silent:
+                print("Cell.Sphere - Error: could not create a sphere. Returning None.")
             return None
-        c = Wire.Circle(origin=Vertex.Origin(), radius=radius, sides=vSides, fromAngle=0, toAngle=180, close=False, direction=[0, 0, 1], placement="center")
-        c = Topology.Rotate(c, origin=Vertex.Origin(), axis=[1, 0, 0], angle=90)
-        sphere = Topology.Spin(c, origin=Vertex.Origin(), triangulate=False, direction=[0, 0, 1], angle=360, sides=uSides, tolerance=tolerance)
-        if Topology.Type(sphere) == Topology.TypeID("CellComplex"):
-            sphere = CellComplex.ExternalBoundary(sphere)
-        if Topology.Type(sphere) == Topology.TypeID("Shell"):
-            sphere = Cell.ByShell(sphere)
         if placement.lower() == "bottom":
             sphere = Topology.Translate(sphere, 0, 0, radius)
         elif placement.lower() == "lowerleft":

topologicpy/EnergyModel.py

@@ -201,6 +201,51 @@ class EnergyModel:
                 warnings.warn("EnergyModel.ByTopology - Error: Could not import openstudio.Please try to install openstudio manually. Returning None.")
                 return None
 
+
+        def load_openstudio_model(osm_path: str, allow_newer: bool = True):
+            """
+            Load an OpenStudio .osm file and return an openstudio.model.Model.
+            Uses loadModelFromString to avoid SWIG path overload issues.
+            """
+            import os
+
+            if not os.path.exists(osm_path):
+                raise FileNotFoundError(osm_path)
+
+            vt = openstudio.osversion.VersionTranslator()
+            if allow_newer:
+                vt.setAllowNewerVersions(True)
+
+            # 1) Robust path-agnostic route: read text and load from string
+            with open(osm_path, "r", encoding="utf-8") as f:
+                txt = f.read()
+            model_opt = vt.loadModelFromString(txt)  # <- avoids path type mismatches
+
+            # 2) Fallback: try the filesystem-path overloads if needed
+            if (not model_opt) or (not model_opt.is_initialized()):
+                os_path = None
+                for maker in (
+                    lambda s: getattr(openstudio, "path")(s),
+                    lambda s: getattr(openstudio, "toPath")(s),
+                    lambda s: getattr(openstudio.openstudioutilitiescore, "toPath")(s),
+                ):
+                    try:
+                        os_path = maker(osm_path)
+                        break
+                    except Exception:
+                        pass
+                if os_path is not None:
+                    try:
+                        model_opt = vt.loadModel(os_path)
+                    except TypeError:
+                        model_opt = openstudio.model.Model.load(os_path)
+
+            if (not model_opt) or (not model_opt.is_initialized()):
+                raise RuntimeError(f"Failed to load OpenStudio model from: {osm_path}")
+
+            model = model_opt.get()
+            return model
+    
         def getKeyName(d, keyName):
             keys = d.Keys()
             for key in keys:
@@ -243,21 +288,23 @@ class EnergyModel:
         
         if not osModelPath:
             import os
-            osModelPath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "OSMTemplate-OfficeBuilding-3.5.0.osm")
+            osModelPath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "OSMTemplate-OfficeBuilding-3.10.0.osm")
         if not weatherFilePath or not designDayFilePath:
             import os
             weatherFilePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "GBR_London.Gatwick.037760_IWEC.epw")
             designDayFilePath = os.path.join(os.path.dirname(os.path.realpath(__file__)), "assets", "EnergyModel", "GBR_London.Gatwick.037760_IWEC.ddy")
-        translator = openstudio.osversion.VersionTranslator()
+
+        #translator = openstudio.osversion.VersionTranslator()
         # DEBUGGING
         #osmFile = openstudio.openstudioutilitiescore.toPath(osModelPath)
         #osModel = translator.loadModel(osmFile)
-        osModel = translator.loadModel(osModelPath)
-        if osModel.isNull():
-            print("EnergyModel.ByTopology - Error: The openstudio model is null. Returning None.")
-            return None
-        else:
-            osModel = osModel.get()
+        #osModel = translator.loadModel(osModelPath)
+        osModel = load_openstudio_model(osModelPath, allow_newer=True)
+        # if osModel.isNull():
+        #     print("EnergyModel.ByTopology - Error: The openstudio model is null. Returning None.")
+        #     return None
+        # else:
+        #     osModel = osModel.get()
         # DEBUGGING
         #osEPWFile = openstudio.openstudioutilitiesfiletypes.EpwFile.load(openstudio.toPath(weatherFilePath))
         osEPWFile = openstudio.openstudioutilitiesfiletypes.EpwFile.load(weatherFilePath)
@@ -265,8 +312,8 @@ class EnergyModel:
             osEPWFile = osEPWFile.get()
             openstudio.model.WeatherFile.setWeatherFile(osModel, osEPWFile)
         # DEBUGGING
-        #ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(openstudio.toPath(designDayFilePath))
-        ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(designDayFilePath)
+        ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(openstudio.toPath(designDayFilePath))
+        #ddyModel = openstudio.openstudioenergyplus.loadAndTranslateIdf(designDayFilePath)
         if ddyModel.is_initialized():
             ddyModel = ddyModel.get()
             for ddy in ddyModel.getObjectsByType(openstudio.IddObjectType("OS:SizingPeriod:DesignDay")):
@@ -1195,3 +1242,57 @@ class EnergyModel:
             return None
         return units
     
+    @staticmethod
+    def Version(check: bool = True, silent: bool = False):
+        """
+        Returns the OpenStudio SDK version number.
+
+        Parameters
+        ----------
+        check : bool , optional
+            if set to True, the version number is checked with the latest version on PyPi. Default is True.
+        
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+        
+        Returns
+        -------
+        str
+            The OpenStudio SDK version number.
+
+        """
+        from topologicpy.Helper import Helper
+        try:
+            import openstudio
+            openstudio.Logger.instance().standardOutLogger().setLogLevel(openstudio.Fatal)
+        except:
+            if not silent:
+                print("EnergyModel.Version - Information: Installing required openstudio library.")
+            try:
+                os.system("pip install openstudio")
+            except:
+                os.system("pip install openstudio --user")
+            try:
+                import openstudio
+                openstudio.Logger.instance().standardOutLogger().setLogLevel(openstudio.Fatal)
+                if not silent:
+                    print("EnergyModel.Version - Information: openstudio library installed correctly.")
+            except:
+                if not silent:
+                    print("EnergyModel.Version - Error: Could not import openstudio.Please try to install openstudio manually. Returning None.")
+                return None
+        import requests
+        from packaging import version
+
+        result = getattr(openstudio, "openStudioVersion", None)
+        if callable(result):
+            result = result()
+        else:
+            if not silent:
+                print("EnergyModel.Version - Error: Could not retrieve the openstudio SDK version number. Returning None.")
+            return None
+        if check == True:
+            result = Helper.CheckVersion("openstudio", result, silent=silent)
+        return result
+        
+        

topologicpy/Graph.py

@@ -784,7 +784,291 @@ class Graph:
             return csv_buffer.getvalue()
         except Exception as e:
             return ""
-        
+
+    @staticmethod
+    def AdjacencyMatrixFigure(graph,
+                            vertexKey: str = None,
+                            showZero: bool = False,
+                            zeroChar: str = "·",
+                            zeroColor: str = 'rgba(0,0,0,0)',
+                            valueColor: str = 'rgba(0,0,0,0.05)',
+                            diagonalHighlight: bool = True,
+                            diagonalColor: str = 'rgba(0,0,0,0)',
+                            title: str = None,
+                            cellSize: int = 24,
+                            fontFamily: str = "Arial",
+                            fontSize: int = 12,
+                            fontColor: str = 'rgba(0,0,0,0)',
+                            backgroundColor: str = 'rgba(0,0,0,0)',
+                            headerColor: str = 'rgba(0,0,0,0)',
+                            reverse=False,
+                            edgeKeyFwd=None,
+                            edgeKeyBwd=None,
+                            bidirKey=None,
+                            bidirectional=True,
+                            useEdgeIndex=False,
+                            useEdgeLength=False,
+                            mantissa: int = 6,
+                            tolerance=0.0001,
+                            silent: bool = False):
+        """
+        Returns a Plotly table figure visualizing the adjacency matrix of a Graph.
+
+        Parameters
+        ----------
+        graph : topologic_core.Graph
+            The input graph.
+        vertexKey : str , optional
+            If set, the returned list of vertices is sorted according to the dictionary values stored under this key. Default is None.
+        showZero : bool, optional
+            If True, show zeros as "0"; if False, show a subtle glyph (zero_char) or blank. Default is False.
+        zeroChar : str, optional
+            Character to display for zero entries when show_zero is False. Default is "·".
+        zeroColor : list or str , optional
+            The desired color to display for zero-valued cells. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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 'rgba(0,0,0,0)' (transparent).
+        valueColor : list or str , optional
+            The desired color to display for non-zero-valued cells. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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 'rgba(0,0,0,0.35)' (slight highlight).
+        diagonalHighlight : bool, optional
+            If True, lightly highlight diagonal cells. Default is True.
+        diagonalColor : list or str , optional
+            The desired diagonal highlight color. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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 'rgba(0,0,0,0)' (transparent).
+        title : str, optional
+            Optional figure title.
+        cellSize : int, optional
+            Approximate pixel height of each table row. Default is 24.
+        fontFamily : str, optional
+            Font family for table text. Default is "Arial".
+        fontSize : int, optional
+            Font size for table text. Default is 12.
+        fontColor : list or str , optional
+            The desired font color. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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 'rgba(0,0,0,0)' (transparent).
+        backgroundColor : list or str , optional
+            The desired background color. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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 'rgba(0,0,0,0)' (transparent).
+        headerColor : list or str , optional
+            The desired header color. This can be any color list or plotly color string and may be specified as:
+            - An rgb list (e.g. [255,0,0])
+            - A cmyk list (e.g. [0.5, 0, 0.25, 0.2])
+            - 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 'rgba(0,0,0,0)' (transparent).
+        reverse : bool , optional
+            If set to True, the vertices are sorted in reverse order (only if vertexKey is set). Otherwise, they are not. Default is False.
+        edgeKeyFwd : str , optional
+            If set, the value at this key in the connecting edge from start vertex to end vertex (forward) will be used instead of the value 1. Default is None. useEdgeIndex and useEdgeLength override this setting.
+        edgeKeyBwd : str , optional
+            If set, the value at this key in the connecting edge from end vertex to start vertex (backward) will be used instead of the value 1. Default is None. useEdgeIndex and useEdgeLength override this setting.
+        bidirKey : bool , optional
+            If set to True or False, this key in the connecting edge will be used to determine is the edge is supposed to be bidirectional or not. If set to None, the input variable bidrectional will be used instead. Default is None
+        bidirectional : bool , optional
+            If set to True, the edges in the graph that do not have a bidireKey in their dictionaries will be treated as being bidirectional. Otherwise, the start vertex and end vertex of the connecting edge will determine the direction. Default is True.
+        useEdgeIndex : bool , optional
+            If set to True, the adjacency matrix values will the index of the edge in Graph.Edges(graph). Default is False. Both useEdgeIndex, useEdgeLength should not be True at the same time. If they are, useEdgeLength will be used.
+        useEdgeLength : bool , optional
+            If set to True, the adjacency matrix values will the length of the edge in Graph.Edges(graph). Default is False. Both useEdgeIndex, useEdgeLength should not be True at the same time. If they are, useEdgeLength will be used.
+        mantissa : int , optional
+            The number of decimal places to round the result to. Default is 6.
+        tolerance : float , optional
+            The desired tolerance. Default is 0.0001.
+        silent : bool, optional
+            If True, suppresses warning messages. Default is False.
+
+        Returns
+        -------
+        plotly.graph_objs._figure.Figure
+            A Plotly table figure containing the adjacency matrix table.
+        """
+
+        from topologicpy.Topology import Topology
+        from topologicpy.Graph import Graph
+        from topologicpy.Dictionary import Dictionary
+        import plotly.graph_objects as go
+
+        if not Topology.IsInstance(graph, "Graph"):
+            if not silent:
+                print("Plotly.AdjacencyMatrixTable - Error: The input is not a valid Graph. Returning None.")
+            return None
+
+        # Build adjacency matrix
+        adj = Graph.AdjacencyMatrix(graph,
+                                    vertexKey=vertexKey,
+                                    reverse=reverse,
+                                    edgeKeyFwd=edgeKeyFwd,
+                                    edgeKeyBwd=edgeKeyBwd,
+                                    bidirKey=bidirKey,
+                                    bidirectional=bidirectional,
+                                    useEdgeIndex=useEdgeIndex,
+                                    useEdgeLength=useEdgeLength,
+                                    mantissa=mantissa,
+                                    tolerance=tolerance)
+
+        if adj is None or not isinstance(adj, list) or len(adj) == 0:
+            if not silent:
+                print("Plotly.AdjacencyMatrixTable - Warning: Empty adjacency matrix. Returning None.")
+            return None
+
+        n = len(adj)
+        # Validate squareness
+        if any((not isinstance(row, list) or len(row) != n) for row in adj):
+            if not silent:
+                print("Plotly.AdjacencyMatrixTable - Error: Adjacency matrix must be square. Returning None.")
+            return None
+
+        # Derive labels
+        verts = Graph.Vertices(graph)
+        labels = [Dictionary.ValueAtKey(Topology.Dictionary(v), vertexKey, str(i)) for i, v in enumerate(verts)]
+        if len(labels) > 0 and not vertexKey == None:
+            labels.sort()
+            if reverse == True:
+                labels.reverse()
+        # Build display matrix (strings) while keeping a parallel style mask for diagonal
+        display_matrix = []
+        diag_mask = []
+        for r in range(n):
+            row_vals = []
+            row_diag = []
+            for c in range(n):
+                v = adj[r][c]
+                if v == 0:
+                    row_vals.append("0" if showZero else (zeroChar if zeroChar else ""))
+                else:
+                    # Keep integers unpadded for clarity; cast others nicely
+                    row_vals.append(str(int(v)) if isinstance(v, (int, float)) and float(v).is_integer() else str(v))
+                row_diag.append(r == c)
+            display_matrix.append(row_vals)
+            diag_mask.append(row_diag)
+
+        # Construct header and cells for Plotly Table
+        # Header: blank corner + column labels
+        header_values = [""] + labels
+
+        # Body: first column is row labels, then matrix cells as strings
+        # Plotly Table expects columns as lists; we need to transpose
+        columns = []
+        # Column 0: row labels
+        columns.append(labels)
+        # Subsequent columns: for each c, collect display_matrix[r][c]
+        for c in range(n):
+            columns.append([display_matrix[r][c] for r in range(n)])
+
+        # Flatten cell fill_colors to highlight diagonal subtly.
+        # Plotly Table allows per-cell fillcolor via a 2D list matching the table shape for 'cells'.
+        # Our cells shape is n rows x (n+1) cols (including row label column).
+
+        fill_colors = []
+        # Column 0: row labels (no highlight)
+        fill_colors.append([headerColor] * n)
+
+        # Columns 1..n: highlight diagonal where row index r == (column_index-1)
+        for c in range(1, n + 1):
+            col_colors = []
+            for r in range(n):
+                if diagonalHighlight and r == (c - 1):
+                    col_colors.append(diagonalColor)
+                elif columns[c][r] == "0" or columns[c][r] == zeroChar:
+                    col_colors.append(zeroColor)
+                else:
+                    col_colors.append(valueColor)
+            fill_colors.append(col_colors)
+
+        # Minimal line style
+        line_color = "rgba(0,0,0,0.12)"
+        # --- Sizing to prevent cropped text ---
+        # Heuristic widths (pixels)
+        max_label_len = max(len(str(x)) for x in labels) if labels else 1
+        row_label_px = max(120, min(320, 8 * max_label_len))  # scale with label length
+        cell_px = 36 if n <= 30 else (30 if n <= 50 else 24)   # narrower cells for very wide matrices
+
+        # Adaptive cell font size for many columns
+        fontSize = max(fontSize, 3)
+        cell_font_size = fontSize if n <= 35 else (fontSize-1 if n <= 60 else fontSize-2)
+
+        # Figure width: row label column + all matrix columns
+        fig_width = row_label_px + n * cell_px
+        fig_width = max(600, min(2400, fig_width))  # clamp to reasonable bounds
+
+        # Increase row height a bit for readability
+        cellSize = max(cellSize, 26)
+
+        # Column widths in px (Plotly Table accepts pixel widths)
+        columnwidth = [row_label_px] + [cell_px] * n
+        fig = go.Figure(
+            data=[
+                go.Table(
+                    header=dict(
+                        values=header_values,
+                        align="center",
+                        font=dict(family=fontFamily, size=cell_font_size, color=fontColor),
+                        fill_color=headerColor,
+                        line_color=line_color,
+                        height=cellSize + 4  # a touch taller for the header
+                    ),
+                    cells=dict(
+                        values=columns,
+                        align=["right"] + ["center"] * n,
+                        font=dict(family=fontFamily, size=cell_font_size, color=fontColor),
+                        fill_color=fill_colors,
+                        line_color=line_color,
+                        height=cellSize
+                    ),
+                    columnorder=list(range(n + 1)),
+                    columnwidth=columnwidth
+                )
+            ]
+        )
+
+        # Layout: generous margins, white background, optional title
+        fig.update_layout(
+            title=dict(text=title, x=0.5, xanchor="center") if title else None,
+            paper_bgcolor="white",
+            plot_bgcolor=backgroundColor,
+            margin=dict(l=20, r=20, t=40 if title else 10, b=20)
+        )
+
+        return fig
+
     @staticmethod
     def AdjacencyList(graph, vertexKey=None, reverse=True, tolerance=0.0001):
         """

topologicpy/Helper.py

@@ -90,6 +90,53 @@ class Helper:
 
         return sorted(bin_averages)
     
+    def CheckVersion(library: str = None, version: str = None, silent: bool = False):
+        """
+        Compare an input version with the latest version of a Python library on PyPI.
+
+        Parameters
+        ----------
+        library : str
+            The input software library name. Default is None.
+        version : str
+            The input software version number to compare. Default is None.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+
+        Returns:
+            str: A message indicating whether the input version is less than,
+                equal to, or greater than the latest version on PyPI.
+        """
+        import requests
+        from packaging import version as ver
+
+        try:
+            # Fetch library data from PyPI
+            url = f"https://pypi.org/pypi/{library}/json"
+            response = requests.get(url)
+            response.raise_for_status()
+
+            # Extract the latest version from the JSON response
+            data = response.json()
+            latest_version = data['info']['version']
+
+            # Compare versions using the packaging library
+            if ver.parse(version) < ver.parse(latest_version):
+                return (f"The version that you are using ({version}) is OLDER than the latest version ({latest_version}) from PyPI. Please consider upgrading to the latest version.")
+            elif ver.parse(version) == ver.parse(latest_version):
+                return (f"The version that you are using ({version}) is EQUAL TO the latest version available on PyPI.")
+            else:
+                return (f"The version that you are using ({version}) is NEWER than the latest version ({latest_version}) available from PyPI.")
+
+        except requests.exceptions.RequestException as e:
+            if not silent:
+                print("Helper.CheckVersion - Error: Could not fetch data from PyPI. Returning None")
+            return None
+        except KeyError:
+            if not silent:
+                print("Helper.CheckVersion - Error: Could not fetch data from PyPI. Returning None")
+            return None
+    
     @staticmethod
     def ClosestMatch(item, listA):
         """
@@ -788,58 +835,25 @@ class Helper:
         return returnList
     
     @staticmethod
-    def Version():
+    def Version(check: bool = True, silent: bool = False):
         """
         Returns the current version of the software.
 
         Parameters
         ----------
-
+        check : bool , optional
+            if set to True, the version number is checked with the latest version on PyPi. Default is True.
+        silent : bool , optional
+            If set to True, error and warning messages are suppressed. Default is False.
+        
         Returns
         -------
         str
-            The current version of the software.
+            The current version of the software. Optionally, includes a check with PyPi.
 
         """
         
-        import requests
-        from packaging import version
-
-        def compare_version_with_pypi(library_name, input_version):
-            """
-            Compare an input version with the latest version of a Python library on PyPI.
-
-            Args:
-                library_name (str): The name of the Python library on PyPI.
-                input_version (str): The version number to compare (e.g., "0.7.58").
-
-            Returns:
-                str: A message indicating whether the input version is less than,
-                    equal to, or greater than the latest version on PyPI.
-            """
-            try:
-                # Fetch library data from PyPI
-                url = f"https://pypi.org/pypi/{library_name}/json"
-                response = requests.get(url)
-                response.raise_for_status()
-
-                # Extract the latest version from the JSON response
-                data = response.json()
-                latest_version = data['info']['version']
-
-                # Compare versions using the packaging library
-                if version.parse(input_version) < version.parse(latest_version):
-                    return (f"The version that you are using ({input_version}) is OLDER than the latest version {latest_version} from PyPI. Please consider upgrading to the latest version.")
-                elif version.parse(input_version) == version.parse(latest_version):
-                    return (f"The version that you are using ({input_version}) is the latest version available on PyPI.")
-                else:
-                    return (f"The version that you are using ({input_version}) is NEWER than the latest version ({latest_version}) available from PyPI.")
-
-            except requests.exceptions.RequestException as e:
-                return f"Error fetching data from PyPI: {e}"
-            except KeyError:
-                return "Error: Unable to find the latest version in the PyPI response."
-        
-        current_version = topologicpy.__version__
-        result = compare_version_with_pypi("topologicpy", current_version)
+        result = topologicpy.__version__
+        if check == True:
+            result = Helper.CheckVersion("topologicpy", result, silent=silent)
         return result

topologicpy/Plotly.py

@@ -1447,8 +1447,10 @@ class Plotly:
         ----------
         matrix : list or numpy.array
             The matrix to display.
-        categories : list
-            The list of categories to use on the X and Y axes.
+        xCategories : list
+            The list of categories to use on the X axis.
+        yCategories : list
+            The list of categories to use on the Y axis.
         minValue : float , optional
             The desired minimum value to use for the color scale. If set to None, the minmum value found in the input matrix will be used. Default is None.
         maxValue : float , optional

topologicpy/Topology.py

@@ -8320,6 +8320,8 @@ class Topology():
              absolute=False,
              sides=8,
              angle=0,
+
+             showFigure=True,
              mantissa=6,
              tolerance=0.0001,
              silent=False):
@@ -8507,6 +8509,8 @@ class Topology():
             The units used in the colorbar. Default is ""
         colorScale : str , optional
             The desired type of plotly color scales to use (e.g. "viridis", "plasma"). Default is "viridis". For a full list of names, see https://plotly.com/python/builtin-colorscales/.
+        showFigure : bool , optional
+            If set to True, the figure will be shown and a None is returned. If not, the figure will be returned, but not shown. Default is True.
         mantissa : int , optional
             The desired length of the mantissa for the values listed on the colorbar. Default is 6.
         tolerance : float , optional
@@ -8516,7 +8520,8 @@ class Topology():
 
         Returns
         -------
-        None
+        Plotly figure
+            The created plotly figure.
 
         """
 
@@ -8691,7 +8696,27 @@ class Topology():
                                      tolerance=tolerance)
         if showScale:
             figure = Plotly.AddColorBar(figure, values=cbValues, nTicks=cbTicks, xPosition=cbX, width=cbWidth, outlineWidth=cbOutlineWidth, title=cbTitle, subTitle=cbSubTitle, units=cbUnits, colorScale=colorScale, mantissa=mantissa)
-        Plotly.Show(figure=figure, renderer=renderer, camera=camera, center=center, up=up, projection=projection)
+        if showFigure:
+            Plotly.Show(figure=figure, renderer=renderer, camera=camera, center=center, up=up, projection=projection)
+            return None
+        if "ortho" in projection.lower():
+            camera_settings = dict(eye=dict(x=camera[0], y=camera[1], z=camera[2]),
+                                center=dict(x=center[0], y=center[1], z=center[2]),
+                                up=dict(x=up[0], y=up[1], z=up[2]),
+                                projection=dict(type="orthographic"))
+        else:
+            camera_settings = dict(eye=dict(x=camera[0], y=camera[1], z=camera[2]),
+                                center=dict(x=center[0], y=center[1], z=center[2]),
+                                up=dict(x=up[0], y=up[1], z=up[2]),
+                                projection=dict(type="perspective"))
+
+        figure.update_layout(
+            scene_camera = camera_settings,
+            scene=dict(aspectmode="data"),
+            autosize=True,
+            margin=dict(l=40, r=40, t=40, b=40)
+            )
+        return figure
 
     @staticmethod
     def SmallestFaces(topology, removeCoplanarFaces: bool = False, epsilon: float = 0.001, tolerance: float = 0.0001, silent: bool = False):

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.8.51'
+__version__ = '0.8.54'

{topologicpy-0.8.51.dist-info → topologicpy-0.8.54.dist-info}/METADATA

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

@@ -2,7 +2,7 @@ topologicpy/ANN.py,sha256=gpflv4lFypOW789vO7mSkMLaMF_ZftVOCqCvtGr6-JA,47873
 topologicpy/Aperture.py,sha256=wNn5miB_IrGCBYuQ18HXQYRva20dUC3id4AJCulL7to,2723
 topologicpy/BVH.py,sha256=JA4bb-9hgMfVZ_syzmSmTL3ueCq-0vMUGMPZxNcawAY,13023
 topologicpy/CSG.py,sha256=09la1-xzS9vr-WnV7tpJ0I-mkZ-XY0MRSd5iB50Nfgw,15556
-topologicpy/Cell.py,sha256=gldsBl3LnrvTRS4SnK9aAM8k_kS1aNovTjUNHxQRNKk,175319
+topologicpy/Cell.py,sha256=ndrfovjwEEQTJ0B5DuthuCBDdVg9-1i_MX8Dtj-wD4E,177330
 topologicpy/CellComplex.py,sha256=Kbz63rGeE08bJfMXFvB-AptoKHiaCK5OtiV1wz8Y-Fk,68081
 topologicpy/Cluster.py,sha256=G49AuhJHQ1s819cB5MtVdmAGgkag19IC3dRP1ub1Wh4,58608
 topologicpy/Color.py,sha256=hzSmgBWhiuYc55RSipkQNIgGtgyhC5BqY8AakNYEK-U,24486
@@ -10,29 +10,29 @@ topologicpy/Context.py,sha256=G3CwMvN8Jw2rnQRwB-n4MaQq_wLS0vPimbXKwsdMJ80,3055
 topologicpy/DGL.py,sha256=O7r22ss0tgak4kWaACkyExhR_rZ46O_bqIBpxAcwJkw,138918
 topologicpy/Dictionary.py,sha256=Z4YQ88tONWd-0X0dENQ8IZqIOa9mbBqhJkTBsHmft2g,44619
 topologicpy/Edge.py,sha256=DifItuyabFDUFC7CVMlt2DeMFMNaGOqCg43iU9CPP0A,74029
-topologicpy/EnergyModel.py,sha256=IiBJNx7F9-8TPMaQn1iQON1ZtTv2nT5kbZHxM_gBCTQ,53773
+topologicpy/EnergyModel.py,sha256=hB1aiJe45gdDMFm1AhkBr-1djjtXSzn24iRpQMk43-4,57749
 topologicpy/Face.py,sha256=aX9EcR3JGbLITElhd25J0Z8m9U8KkmbYivGg3oZN-Uw,202296
-topologicpy/Graph.py,sha256=o6aK18tCTkfzsNFOTAU-wIPG2p3g_vpm6n7YHc44bYU,691239
+topologicpy/Graph.py,sha256=Oa0oOrPoOSUGL5fvJYHBH_r6kRZ944wk-P828GyAjk4,705757
 topologicpy/Grid.py,sha256=3OsBMyHh4w8gpFOTMKHMNTpo62V0CwRNu5cwm87yDUA,18421
-topologicpy/Helper.py,sha256=aGmndgmEztjVNU-wW9OoHDel7wzapprM0TjA7f2AoS8,31188
+topologicpy/Helper.py,sha256=Nr6pyzl0sZm4Cu11wOqoYKu6yYal5N6A9jErXnaZBJc,31765
 topologicpy/Honeybee.py,sha256=C7Am0kCK3a5rt7Jpu2EIgqeR114ZJWtsx4_DBcr5hQA,21716
 topologicpy/Matrix.py,sha256=bOofT34G3YHu9aMIWx60YHAJga4R0GbDjsZBUD4Hu_k,22706
 topologicpy/Neo4j.py,sha256=J8jU_mr5-mWC0Lg_D2dMjMlx1rY_eh8ks_aubUuTdWw,22319
-topologicpy/Plotly.py,sha256=RXGeEBwVs8unJaT9vv_FBmAFfKd-1Z5x3V8oeKE43Bs,122924
+topologicpy/Plotly.py,sha256=kF7JwBMWJQAuGezaJYI6Cq7ErNwEtcKzaExOfdGPIMc,123003
 topologicpy/Polyskel.py,sha256=oVfM4lqSMPTjnkHfsRU9VI8Blt6Vf0LVPkD9ebz7Wmw,27082
 topologicpy/PyG.py,sha256=wOsoBFxMgwZYWjj86OMkz_PJuQ02locV_djhSDD6dVc,109644
 topologicpy/ShapeGrammar.py,sha256=KYsKDLXWdflAcYMAIz84AUF-GMkbTmaBDd2-ovbilqU,23336
 topologicpy/Shell.py,sha256=ioO4raCJfXtYldQg-adpcLVeJPEA6od6cAA5ro7t6r4,96792
 topologicpy/Speckle.py,sha256=-eiTqJugd7pHiHpD3pDUcDO6CGhVyPV14HFRzaqEoaw,18187
 topologicpy/Sun.py,sha256=8S6dhCKfOhUGVny-jEk87Q08anLYMB1JEBKRGCklvbQ,36670
-topologicpy/Topology.py,sha256=MoEszjDhEiCVYTO4IFxYsYjYj4Vg5TnWUcnoPMNj-Nc,471350
+topologicpy/Topology.py,sha256=R5Ac3V_ADDRDZjhpcNvhM3AvDOLU6ORvB3yILyEkxnI,472559
 topologicpy/Vector.py,sha256=pEC8YY3TeHGfGdeNgvdHjgMDwxGabp5aWjwYC1HSvMk,42236
 topologicpy/Vertex.py,sha256=0f6HouARKaCuxhdxsUEYi8T9giJycnWhQ8Cn70YILBA,84885
 topologicpy/Wire.py,sha256=gjgQUGHdBdXUIijgZc_VIW0E39w-smaVhhdl0jF63fQ,230466
 topologicpy/__init__.py,sha256=RMftibjgAnHB1vdL-muo71RwMS4972JCxHuRHOlU428,928
-topologicpy/version.py,sha256=xWa9BLlvIYvhh3MnyCUV3ug10L4hsf2fDMNf9z_dCY4,23
-topologicpy-0.8.51.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.8.51.dist-info/METADATA,sha256=6kYuhs7iebTG3MIvoPQyA558AmaRzFkRce7CKgKBgr0,10535
-topologicpy-0.8.51.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-topologicpy-0.8.51.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.8.51.dist-info/RECORD,,
+topologicpy/version.py,sha256=4rZKb5aqUqZkGV-bsREBGvAbGTFOte68oezCn9q__NM,23
+topologicpy-0.8.54.dist-info/licenses/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.8.54.dist-info/METADATA,sha256=mfbs0io_WTGxQzjuphNKxMpb12yRIYEt43sfj9gSVc4,10535
+topologicpy-0.8.54.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+topologicpy-0.8.54.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.8.54.dist-info/RECORD,,