topologicpy 0.7.80__py3-none-any.whl → 0.7.82__py3-none-any.whl

topologicpy/Face.py

@@ -1649,7 +1649,7 @@ class Face():
         return are_planes_coplanar(plane_a, plane_b, tolerance=tolerance)
 
     @staticmethod
-    def Isovist(face, vertex, obstacles: list = [], direction: list = [0,1,0], fov: float = 360, mantissa: int = 6, tolerance: float = 0.0001):
+    def Isovist(face, vertex, obstacles: list = [], direction: list = [0,1,0], fov: float = 360, transferDictionaries: bool = False, metrics: bool = False, mantissa: int = 6, tolerance: float = 0.0001):
         """
         Returns the face representing the isovist projection from the input viewpoint.
         This method assumes all input is in 2D. Z coordinates are ignored.
@@ -1671,6 +1671,25 @@ class Face():
         fov : float , optional
             The horizontal field of view (fov) angle in degrees. See https://en.wikipedia.org/wiki/Field_of_view.
             The acceptable range is 1 to 360. The default is 360.
+        transferDictionaries : bool , optional
+            If set to True, the dictionaries of the encountered edges will be transfered to the isovist edges. The default is False.
+        metrics : bool , optional
+            If set to True, the following metrics are calculated and stored in the dictionary of the returned isovist. The keys of the values are:
+            - viewpoint : list , the x , y , z coordinates of the location of the viewpoint.
+            - direction : list , the direction of the view.
+            - fov : int, Field of view angle.
+            - area : float , the area of the isovist.
+            - perimeter : float , the perimeter length of the isovist
+            - compactness : float , how closely the shape of the isovist approximates a circle (the most compact geometric shape).
+            - d_max : float, Maximum Visibility Distance. the length of the longest straight line that can be seen from the viewpoint.
+            - v_max : list, Furthest Point measures the x , y , z coordinates of the furthest visible point from the viewpoint.
+            - v_d :  list, Visibility Distribution quantifies the angular distribution (in degrees) of visible points across the isovist.
+                    This metric can tell you whether the visibility from a point is more spread out or concentrated in a certain direction. A uniform visibility distribution indicates a more balanced visual field, while a skewed distribution suggests that the observer's line of sight is constrained in certain directions.
+            - v_density : float, Viewpoint Density which refers to the number of visible points per unit area within the isovist.
+            - symmetry : float, Symmetry measures how balanced or symmetrical the isovist is around the point of observation.
+            - 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.
         mantissa : int , optional
             The desired length of the mantissa. The default is 6.
         tolerance : float , optional:
@@ -1690,8 +1709,132 @@ class Face():
         from topologicpy.Cluster import Cluster
         from topologicpy.Topology import Topology
         from topologicpy.Vector import Vector
+        from topologicpy.Dictionary import Dictionary
+        from topologicpy.Helper import Helper
+
+        import math
+        import numpy as np
+
+        def calculate_angle(viewpoint, vertex):
+            # Calculate the angle between the viewpoint and the vertex in the 2D plane
+            # Viewpoint is (x, y, z), and vertex is (x, y)
+            dx = vertex[0] - viewpoint[0]
+            dy = vertex[1] - viewpoint[1]
+            
+            # Return the angle in radians using the arctangent of the y/x difference
+            return math.degrees(math.atan2(dy, dx))
+        
+        def visibility_distribution(viewpoint, isovist_vertices):
+            angles = []
+            # Calculate the angle of each vertex with respect to the viewpoint
+            for vertex in isovist_vertices:
+                angle = calculate_angle(viewpoint, vertex)
+                angles.append(angle)
+            # Sort the angles to analyze the distribution
+            angles = np.sort(angles)
+            return list(angles)
+
+        def isovist_symmetry(viewpoint, isovist_vertices):
+            """
+            Calculates the symmetry of the isovist polygon.
+            
+            Parameters:
+            - viewpoint: a tuple (x, y) of the viewpoint.
+            - isovist_vertices: a list of tuples, each representing a vertex (x, y) of the isovist polygon.
+            
+            Returns:
+            - symmetry value: A measure of the symmetry of the isovist.
+            """
+            angles = [calculate_angle(viewpoint, vertex) for vertex in isovist_vertices]
+            angles.sort()
+
+            # Calculate angular deviations from the mean direction
+            mean_angle = np.mean(angles)
+            angular_deviation = np.std(angles)
+            symmetry = angular_deviation / mean_angle if mean_angle != 0 else 0
+            return float(symmetry)
+        
+        # Fractal Dimension (D_f) using Box-counting
+        def fractal_dimension(isovist_vertices):
+            """
+            Calculates the fractal dimension of the isovist boundary using box-counting.
+            
+            Parameters:
+            - isovist_vertices: a list of tuples, each representing a vertex (x, y) of the isovist polygon.
+            
+            Returns:
+            - fractal dimension: A measure of the boundary's complexity.
+            """
+            # Convert isovist vertices into a boundary path (x, y coordinates)
+            boundary_points = np.array(isovist_vertices)
 
-        def vertexPartofFace(vertex, face, tolerance):
+            # Box-counting approach
+            sizes = np.logspace(0, 2, 10)  # Varying box sizes (log scale)
+            sizes[sizes == 0] = 1e-10  # Replace zero counts with a small value
+            counts = []
+            
+            for size in sizes:
+                count = 0
+                for i in range(len(boundary_points)):
+                    if np.abs(boundary_points[i][0] - boundary_points[(i+1)%len(boundary_points)][0]) > size or \
+                    np.abs(boundary_points[i][1] - boundary_points[(i+1)%len(boundary_points)][1]) > size:
+                        count += 1
+                counts.append(count)
+
+            # To avoid log(0), add a small constant to counts
+            counts = np.array(counts)
+            counts = np.where(counts == 0, 1e-10, counts)
+            # Linear regression of log(count) vs log(size) to estimate fractal dimension
+            log_sizes = np.log(sizes)
+            log_counts = np.log(counts)
+            
+            # Perform linear regression (log-log scale)
+            slope, _ = np.polyfit(log_sizes, log_counts, 1)
+            
+            return slope
+
+        # Edge Complexity (E_C)
+        def edge_complexity(isovist_vertices):
+            """
+            Calculates the edge complexity of the isovist boundary.
+            
+            Parameters:
+            - isovist_vertices: a list of tuples, each representing a vertex (x, y) of the isovist polygon.
+            
+            Returns:
+            - edge complexity: A measure of the complexity of the boundary.
+            """
+            angles = []
+            for i in range(len(isovist_vertices)):
+                p1 = isovist_vertices[i]
+                p2 = isovist_vertices[(i + 1) % len(isovist_vertices)]
+                p3 = isovist_vertices[(i + 2) % len(isovist_vertices)]
+
+                # Calculate the angle between each consecutive edge
+                angle = np.arctan2(p3[1] - p2[1], p3[0] - p2[0]) - np.arctan2(p1[1] - p2[1], p1[0] - p2[0])
+                angles.append(np.abs(angle))
+
+            # Complexity is the number of abrupt angle changes
+            complexity = np.sum(np.array(angles) > np.pi / 4)  # e.g., large changes in angles
+            return float(complexity)
+
+        # Mean Visual Field Angle (θ)
+        def mean_visual_field_angle(viewpoint, isovist_vertices):
+            """
+            Calculates the mean visual field angle from the viewpoint to the isovist vertices.
+            
+            Parameters:
+            - viewpoint: a tuple (x, y) of the viewpoint.
+            - isovist_vertices: a list of tuples, each representing a vertex (x, y) of the isovist polygon.
+            
+            Returns:
+            - mean visual field angle in degrees.
+            """
+            angles = [calculate_angle(viewpoint, vertex) for vertex in isovist_vertices]
+            # Return the average angle
+            return np.mean(angles)
+
+        def vertex_part_of_face(vertex, face, tolerance):
             vertices = Topology.Vertices(face)
             for v in vertices:
                 if Vertex.Distance(vertex, v) < tolerance:
@@ -1716,6 +1859,7 @@ class Face():
         normal = Face.Normal(face)
         flat_face = Topology.Flatten(face, origin=origin, direction=normal)
         flat_vertex = Topology.Flatten(vertex, origin=origin, direction=normal)
+        flat_obstacles = [Topology.Flatten(obstacle, origin=origin, direction=normal) for obstacle in obstacles]
 
         eb = Face.ExternalBoundary(flat_face)
         vertices = Topology.Vertices(eb)
@@ -1732,7 +1876,7 @@ class Face():
             new_ib_list.append(Wire.ByVertices(new_vertices, close=True))
 
         flat_face = Face.ByWires(eb, new_ib_list)
-        for obs in obstacles:
+        for obs in flat_obstacles:
             flat_face = Topology.Difference(flat_face, Face.ByWire(obs))
         
         targets = Topology.Vertices(flat_face)
@@ -1751,7 +1895,7 @@ class Face():
         faces = Topology.Faces(shell)
         final_faces = []
         for f in faces:
-            if vertexPartofFace(flat_vertex, f, tolerance=0.001):
+            if vertex_part_of_face(flat_vertex, f, tolerance=0.001):
                 final_faces.append(f)
         shell = Shell.ByFaces(final_faces)
         return_face = Topology.RemoveCoplanarFaces(shell, epsilon=0.1)
@@ -1795,8 +1939,94 @@ class Face():
             return None
         simpler_face = Face.RemoveCollinearEdges(return_face)
         if Topology.IsInstance(simpler_face, "face"):
-            return Topology.Unflatten(simpler_face, origin=origin, direction=normal)
-        return Topology.Unflatten(return_face, origin=origin, direction=normal)
+            if transferDictionaries == True:
+                j_edges = [Topology.Edges(t) for t in obstacles]
+                j_edges = Helper.Flatten(j_edges)
+                j_edges += Topology.Edges(face)
+                i_edges = Topology.Edges(simpler_face)
+                used = [0 for _ in range(len(j_edges))]
+                for i, i_edge in enumerate(i_edges):
+                    d_i = Topology.Dictionary(i_edge)
+                    for j, j_edge in enumerate(j_edges):
+                        if used[j] == 0:
+                            if Edge.IsCollinear(i_edge, j_edge):
+                                d_j = Topology.Dictionary(j_edge)
+                                d_result = Dictionary.ByMergedDictionaries([d_i, d_j])
+                                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)
+        if metrics == True:
+            # 1 Viewpoint
+            viewpoint = Vertex.Coordinates(vertex, mantissa=mantissa)
+            # 2 Direction
+            # direction is given
+            # 3 Field of View (FOV)
+            # fov is given
+            # 4 Area
+            area = round(abs(Face.Area(return_face)), mantissa)
+            # 5 Perimeter
+            perimeter = round(Wire.Length(Face.Wires(return_face)[0]), mantissa)
+            # 6 Compactness
+            compactness = round(Face.Compactness(return_face), mantissa)
+            # 7 Maximum Distance (d_max)
+            vertices = Topology.Vertices(return_face)
+            furthest_vertex = vertices[0]
+            d_max = round(Vertex.Distance(vertex, vertices[0]), mantissa)
+            # 8 Furthest Visible Vertex
+            coords = []
+            for v in vertices:
+                coords.append(Vertex.Coordinates(v, mantissa=mantissa))
+                dis = Vertex.Distance(vertex, v, mantissa=mantissa)
+                if dis > d_max:
+                    d_max  = dis
+                    furthest_vertex = v
+            v_max = Vertex.Coordinates(furthest_vertex, mantissa=mantissa)
+            # 9 Visibility Distribution (v_d)
+            v_d = visibility_distribution(viewpoint, coords)
+            v_d = [round(x) for x in v_d]
+            # 10 Viewpoint density
+            v_density = round(float(len(vertices)) / abs(Face.Area(return_face)), mantissa)
+            # 11 Isovist Symmetry
+            symmetry = round(isovist_symmetry(viewpoint, coords), mantissa)
+            # 12 Fractal Dimension
+            d_f = round(fractal_dimension(coords), mantissa)
+            # 13 Edge Complexity
+            e_c = round(edge_complexity(coords), mantissa)
+            # 14 Mean Visual Field Angle
+            theta = round(mean_visual_field_angle(viewpoint, coords), mantissa)
+            keys = ["viewpoint",
+                    "direction",
+                    "fov",
+                    "area",
+                    "perimeter",
+                    "compactness",
+                    "d_max",
+                    "v_max",
+                    "v_d",
+                    "v_density",
+                    "symmetry",
+                    "d_f",
+                    "e_c",
+                    "theta"]
+            values = [viewpoint,
+                        direction,
+                        fov,
+                        area,
+                        perimeter,
+                        compactness,
+                        d_max,
+                        v_max,
+                        v_d,
+                        v_density,
+                        symmetry,
+                        d_f,
+                        e_c,
+                        theta]
+            d = Dictionary.ByKeysValues(keys, values)
+            return_face = Topology.SetDictionary(return_face, d)
+        return return_face
 
     @staticmethod
     def MedialAxis(face, resolution: int = 0, externalVertices: bool = False, internalVertices: bool = False, toLeavesOnly: bool = False, angTolerance: float = 0.1, tolerance: float = 0.0001):

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.80'
+__version__ = '0.7.82'

{topologicpy-0.7.80.dist-info → topologicpy-0.7.82.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: topologicpy
-Version: 0.7.80
+Version: 0.7.82
 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.7.80.dist-info → topologicpy-0.7.82.dist-info}/RECORD

@@ -10,7 +10,7 @@ topologicpy/DGL.py,sha256=Dd6O08D-vSxpjHYgKm45JpKiaeGvWlg1BRMzYMAXGNc,138991
 topologicpy/Dictionary.py,sha256=0AsGoz48pGTye_F4KcJopNjD9STeQ50LHc6PPvERFaA,31932
 topologicpy/Edge.py,sha256=9u9SdUxuenLUIK26xwFvPoYV34p0dCfXmHHBxdgvAdM,67164
 topologicpy/EnergyModel.py,sha256=AqTtmXE35SxvRXhG3vYAQd7GQDW-6HtjYPHua6ME4Eg,53762
-topologicpy/Face.py,sha256=mS7LI3qIo2jfQbibpInArRfXMmTZd7xU8IdvRYUIGSU,124747
+topologicpy/Face.py,sha256=Y13hw84bjJO8bzEG7sB7PRDxcSqqmGZnNAbIhIUQ1Ys,136243
 topologicpy/Graph.py,sha256=ZhMVB6ntuhIgTrKLUPryeAJFFBF0cnRsNgESbaohOiw,416914
 topologicpy/Grid.py,sha256=9N6PE84qCm40TRi2WtlVZSBwXXr47zHpscEpZHg_JW4,18205
 topologicpy/Helper.py,sha256=vUWbnZJxn0e9YsFUNyJ5Dee8Nh6TmDp9uCzCk4e0qAA,21897
@@ -28,9 +28,9 @@ topologicpy/Vector.py,sha256=A1g83zDHep58iVPY8WQ8iHNrSOfGWFEzvVeDuMnjDNY,33078
 topologicpy/Vertex.py,sha256=mcLJaWFCct03dkVmT25wAl6k0k2EaYvB1PWNO9WQHWg,73465
 topologicpy/Wire.py,sha256=o6MlOjubkJ_f5s1tUamizCsoPKvcQ2OudtJv0yCF-2o,186477
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=aBUXqj0fVv7Q8TFJaUl3kuETKLosGV1MVLaSEclOujg,23
-topologicpy-0.7.80.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.80.dist-info/METADATA,sha256=g22rsF0lEieZmVNOo3LukQGLjnAykoocyDmw2qBPHwg,10513
-topologicpy-0.7.80.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-topologicpy-0.7.80.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.80.dist-info/RECORD,,
+topologicpy/version.py,sha256=rXEi2ZZcGFgf2u3AMH7tyJUFE9nvS8L279fdB54xeCk,23
+topologicpy-0.7.82.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.82.dist-info/METADATA,sha256=CZZqWePZAWM-hGdFkhmjQf9qbm3Ub_fKCPzHnu7RYvk,10513
+topologicpy-0.7.82.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+topologicpy-0.7.82.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.82.dist-info/RECORD,,