topologicpy 0.7.87__py3-none-any.whl → 0.7.91__py3-none-any.whl

topologicpy/Cell.py

@@ -1471,7 +1471,7 @@ class Cell():
         return shells
     
     @staticmethod
-    def InternalVertex(cell, tolerance: float = 0.0001):
+    def InternalVertex(cell, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a vertex that is guaranteed to be inside the input cell.
 
@@ -1481,6 +1481,8 @@ class Cell():
             The input cell.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -1491,12 +1493,14 @@ class Cell():
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(cell, "Cell"):
-            print("Cell.InternalVertex - Error: The input cell parameter is not a valid topologic cell. Returning None.")
+            if not silent:
+                print("Cell.InternalVertex - Error: The input cell parameter is not a valid topologic cell. Returning None.")
             return None
         try:
             return topologic.CellUtility.InternalVertex(cell, tolerance) # Hook to Core
         except:
-            print("Cell.InternalVertex - Error: Could not create an internal vertex. Returning None.")
+            if not silent:
+                print("Cell.InternalVertex - Error: Could not create an internal vertex. Returning None.")
             return None
     
     @staticmethod

topologicpy/Face.py

@@ -1518,7 +1518,7 @@ class Face():
         return list(wires)
 
     @staticmethod
-    def InternalVertex(face, tolerance: float = 0.0001):
+    def InternalVertex(face, tolerance: float = 0.0001, silent: bool = False):
         """
         Creates a vertex guaranteed to be inside the input face.
 
@@ -1528,6 +1528,8 @@ class Face():
             The input face.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------
@@ -1535,22 +1537,53 @@ class Face():
             The created vertex.
 
         """
+        def get_uv_radially():
+            """
+            Generate the points of a grid with a given size n, sorted radially from the center to the periphery.
+            n should be an odd number, ensuring that there's a center point (0, 0).
+            
+            Args:
+                n (int): The size of the grid. It should be odd for a clear center point.
+                
+            Returns:
+                list: A list of tuples (x, y) sorted by radial distance from the center (0, 0).
+            """
+            import math
+
+            points = []
+            n = 100
+            # Iterate over the grid, ranging from -n//2 to n//2
+            for x in range(-n//2, n//2 + 1):
+                for y in range(-n//2, n//2 + 1):
+                    points.append((x, y))
+            
+            # Sort points by their Euclidean distance from the center (0, 0)
+            points.sort(key=lambda point: math.sqrt(point[0]**2 + point[1]**2))
+            return_points = []
+            for p in points:
+                new_p = ((p[0]+50)*0.01, (p[1]+50)*0.01)
+                return_points.append(new_p)
+            return return_points
+        
         from topologicpy.Vertex import Vertex
         from topologicpy.Topology import Topology
 
         if not Topology.IsInstance(face, "Face"):
             return None
-        v = Topology.Centroid(face)
-        if Vertex.IsInternal(v, face, tolerance=tolerance):
-            return v
-        l = [0.4,0.6,0.3,0.7,0.2,0.8,0.1,0.9]
-        for u in l:
-            for v in l:
-                v = Face.VertexByParameters(face, u, v)
-                if Vertex.IsInternal(v, face, tolerance=tolerance):
-                    return v
-        v = topologic.FaceUtility.InternalVertex(face, tolerance) # Hook to Core
-        return v
+        vert = Topology.Centroid(face)
+        if Vertex.IsInternal(vert, face, tolerance=tolerance):
+            return vert
+        uv_list = get_uv_radially()
+        for uv in uv_list:
+            u, v = uv
+            vert = Face.VertexByParameters(face, u, v)
+            if Vertex.IsInternal(vert, face, tolerance=tolerance):
+                return vert
+        if not silent:
+            print("Face.InternalVertex - Warning: Could not find an internal vertex. Returning the first vertex of the face.")
+        vert = Topology.Vertices(face)[0]
+        #v = topologic.FaceUtility.InternalVertex(face, tolerance) # Hook to Core
+        return vert
 
     @staticmethod
     def Invert(face, tolerance: float = 0.0001):
@@ -1657,6 +1690,8 @@ class Face():
         """
         Returns the face representing the isovist projection from the input viewpoint.
         This method assumes all input is in 2D. Z coordinates are ignored.
+        This method and the metrics are largely derived from isovists.org. Even if not explicitly listed, please assume that all credit
+        goes to the authors of that website and its associated software.
 
         Parameters
         ----------
@@ -1698,6 +1733,12 @@ class Face():
             - d_f : float, Fractal Dimension measures the complexity of the isovist's boundary.
             - e_c : float , Edge Complexity measures how complex the edges of the isovist boundary are.
             - theta : float, Mean Visual Field Angle measures the average angular extent of the visible area from the observation point.
+            - occlusivity: float, the proportion of edges of an isovist that are not physically defined.
+            - drift: float, the distance from the observation point to the centroid of its isovist.
+            - closed_perimeter: float, the total length of non-occluded edges of the isovist.
+            - average_radial: float, "the mean view length of all space visible from a location." (from isovists.org)
+            - variance: float, "the mean of the square of deviation between all radial lengths and average radial length of an isovist (Benedikt, 1979)." (from isovists.org)
+            - skewness: float, "the mean of the cube of deviation between all radial lengths and average radial length of an isovist (Benediky, 1979)." (from isovists.org) 
         triangles : bool , optional
             If set to True, the subtended triangles of the isovist are created and stored as contents of the returned isovist face. The default is False.
         mantissa : int , optional
@@ -1901,6 +1942,81 @@ class Face():
             
             return float(distance), Vertex.ByCoordinates(list(closest_point))
         
+        
+        
+        def compute_average_radial_variance_skewness(vertex, edges, mantissa=6):
+            from math import atan2, pi, sqrt, pow
+
+            def subtended_angle(vertex, edge, mantissa=6):
+                """Compute the angle subtended by the edge at point V."""
+                v = Vertex.Coordinates(vertex, mantissa=mantissa)
+                start = Vertex.Coordinates(Edge.StartVertex(edge), mantissa=mantissa)
+                end = Vertex.Coordinates(Edge.EndVertex(edge), mantissa=mantissa)
+                # Calculate the angles of the start and end vertices relative to V
+                angle_start = atan2(start[1] - v[1], start[0] - v[0])
+                angle_end = atan2(end[1] - v[1], end[0] - v[0])
+                # Ensure the angle is in the range [0, 2*pi]
+                angle_start = angle_start if angle_start >= 0 else angle_start + 2 * pi
+                angle_end = angle_end if angle_end >= 0 else angle_end + 2 * pi
+                # Compute the difference and handle wrapping around 2*pi
+                angle_diff = abs(angle_end - angle_start)
+                return min(angle_diff, 2 * pi - angle_diff)
+        
+            total_weighted_distance = 0
+            total_angle_weight = 0
+            total_weighted_squared_deviation = 0
+            total_weighted_cubed_deviation = 0
+            distances = []
+            angles = []
+            for edge in edges:
+                # Calculate the distance between V and the edge
+                distance = Vertex.Distance(vertex, edge, mantissa=mantissa)
+                distances.append(distance)
+
+                # Calculate the subtended angle for the edge
+                angle = subtended_angle(vertex, edge, mantissa=mantissa)
+                angles.append(angle)
+
+                # Weight the distance by the subtended angle
+                total_weighted_distance += distance * angle
+                total_angle_weight += angle
+
+            # Compute the Average Radial value
+            if total_angle_weight == 0:
+                average_radial = 0  # Avoid division by zero
+            else:
+                average_radial = round(total_weighted_distance / total_angle_weight, mantissa)
+
+            # Compute Variance
+            for i, edge in enumerate(edges):
+                # Calculate the distance between V and the edge
+                distance = distances[i]
+                # Calculate the subtended angle for the edge
+                angle = angles[i]
+
+                # Calculate the deviation squared from the average radial
+                deviation_squared = (distance - average_radial) ** 2
+                # Calculate the deviation cubed from the average radial
+                deviation_cubed = (distance - average_radial) ** 3
+                # Weight the squared deviation by the subtended angle
+                total_weighted_squared_deviation += deviation_squared * angle
+                total_weighted_cubed_deviation += deviation_cubed * angle
+
+            # Compute the Variance value
+            if total_angle_weight == 0:
+                variance = 0  # Avoid division by zero
+            else:
+                variance = round(sqrt(total_weighted_squared_deviation / total_angle_weight), mantissa)
+            
+            # Compute the Skewness value
+            if total_angle_weight == 0:
+                skewness = 0  # Avoid division by zero
+            else:
+                skewness = round(pow(total_weighted_cubed_deviation / total_angle_weight, 1/3), mantissa)
+
+            return average_radial, variance, skewness
+        
+        # Main Code
         origin = Topology.Centroid(face)
         normal = Face.Normal(face)
         flat_face = Topology.Flatten(face, origin=origin, direction=normal)
@@ -1989,7 +2105,7 @@ class Face():
             return None
         simpler_face = Face.RemoveCollinearEdges(return_face)
         if Topology.IsInstance(simpler_face, "face"):
-            if transferDictionaries == True:
+            if transferDictionaries == True or metrics == True:
                 j_edges = [Topology.Edges(t) for t in obstacles]
                 j_edges = Helper.Flatten(j_edges)
                 j_edges += Topology.Edges(face)
@@ -1997,19 +2113,24 @@ class Face():
                 used = [0 for _ in range(len(j_edges))]
                 for i, i_edge in enumerate(i_edges):
                     d_i = Topology.Dictionary(i_edge)
+                    d_i = Dictionary.SetValueAtKey(d_i, "occlusive", True)
+                    i_edge = Topology.SetDictionary(i_edge, d_i)
                     for j, j_edge in enumerate(j_edges):
                         if used[j] == 0:
                             if Edge.IsCollinear(i_edge, j_edge):
+                                d_i = Dictionary.SetValueAtKey(d_i, "occlusive", False)
+                                i_edge = Topology.SetDictionary(i_edge, d_i)
                                 d_j = Topology.Dictionary(j_edge)
                                 d_result = Dictionary.ByMergedDictionaries([d_i, d_j])
-                                i_edge = Topology.SetDictionary(i_edge, d_result)
+                                if transferDictionaries == True:
+                                    i_edge = Topology.SetDictionary(i_edge, d_result)
                                 used[j] == 1
             
             return_face = Topology.Unflatten(simpler_face, origin=origin, direction=normal)
-        return_face = Topology.Unflatten(return_face, origin=origin, direction=normal)
+        else:
+            return_face = Topology.Unflatten(return_face, origin=origin, direction=normal)
         if metrics == True:
             vertices = Topology.Vertices(return_face)
-            edges = Topology.Edges(return_face)
             # 1 Viewpoint
             viewpoint = Vertex.Coordinates(vertex, mantissa=mantissa)
             # 2 Direction
@@ -2077,6 +2198,27 @@ class Face():
             e_c = round(edge_complexity(coords), mantissa)
             # 18 Mean Visual Field Angle
             theta = round(mean_visual_field_angle(viewpoint, coords), mantissa)
+            # 19 Occlusivity
+            occ_length = 0
+            edges = Topology.Edges(return_face)
+            for edge in edges:
+                d = Topology.Dictionary(edge)
+                if Dictionary.ValueAtKey(d, "occlusive") == True:
+                    occ_length += Edge.Length(edge)
+            if perimeter > 0:
+                occlusivity = round(occ_length/perimeter, mantissa)
+            else:
+                occlusivity = round(0.0, 6)
+            
+            # 20 Drift
+            drift = Vertex.Distance(vertex, Topology.Centroid(return_face), mantissa=mantissa)
+
+            # 21 Closed Perimeter
+            closed_perimeter = round(perimeter - occ_length, mantissa)
+
+            # 22/23/24 Average Radial, Variance, and Skewness
+            average_radial, variance, skewness = compute_average_radial_variance_skewness(vertex, edges, mantissa=6)
+
             keys = ["viewpoint",
                     "direction",
                     "fov",
@@ -2094,7 +2236,14 @@ class Face():
                     "symmetry",
                     "d_f",
                     "e_c",
-                    "theta"]
+                    "theta",
+                    "occlusivity",
+                    "drift",
+                    "closed_perimeter",
+                    "average_radial",
+                    "variance",
+                    "skewness"]
+            
             values = [viewpoint,
                       direction,
                       fov,
@@ -2112,7 +2261,13 @@ class Face():
                       symmetry,
                       d_f,
                       e_c,
-                      theta]
+                      theta,
+                      occlusivity,
+                      drift,
+                      closed_perimeter,
+                      average_radial,
+                      variance,
+                      skewness]
             d = Dictionary.ByKeysValues(keys, values)
             return_face = Topology.SetDictionary(return_face, d)
         if triangles:
@@ -2365,6 +2520,8 @@ class Face():
             The desired length of the normal edge. The default is 1.
         tolerance : float , optional
             The desired tolerance. The default is 0.0001.
+        silent : bool , optional
+            If set to True, no error and warning messages are printed. Otherwise, they are. The default is False.
 
         Returns
         -------