topologicpy 0.7.68__py3-none-any.whl → 0.7.70__py3-none-any.whl

topologicpy/Graph.py

@@ -7845,6 +7845,7 @@ class Graph:
              sagitta = 0,
              absolute = False,
              sides = 8,
+             angle = 0,
              vertexColor="black",
              vertexSize=6,
              vertexLabelKey=None,
@@ -7893,6 +7894,8 @@ class Graph:
             For example, if the length of the edge is 10, the sagitta is set to 0.5, and absolute is set to False, the sagitta length will be 5. The default is True.
         sides : int , optional
             The number of sides of the arc. The default is 8.
+        angle : float, optional
+            An additional angle in degrees to rotate arcs (where sagitta is more than 0). The default is 0.
         vertexColor : str , optional
             The desired color of the output vertices. This can be any plotly color string and may be specified as:
             - A hex string (e.g. '#ff0000')
@@ -7994,7 +7997,7 @@ class Graph:
             print("Graph.Show - Error: The input graph is not a valid graph. Returning None.")
             return None
         
-        data= Plotly.DataByGraph(graph, sagitta=sagitta, absolute=absolute, sides=sides, vertexColor=vertexColor, vertexSize=vertexSize, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabels=showVertexLabels, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeWidth=edgeWidth, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabels=showEdgeLabels, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
+        data= Plotly.DataByGraph(graph, sagitta=sagitta, absolute=absolute, sides=sides,  angle=angle, vertexColor=vertexColor, vertexSize=vertexSize, vertexLabelKey=vertexLabelKey, vertexGroupKey=vertexGroupKey, vertexGroups=vertexGroups, showVertices=showVertices, showVertexLabels=showVertexLabels, showVertexLegend=showVertexLegend, edgeColor=edgeColor, edgeWidth=edgeWidth, edgeLabelKey=edgeLabelKey, edgeGroupKey=edgeGroupKey, edgeGroups=edgeGroups, showEdges=showEdges, showEdgeLabels=showEdgeLabels, showEdgeLegend=showEdgeLegend, colorScale=colorScale, silent=silent)
         fig = Plotly.FigureByData(data, width=width, height=height, xAxis=xAxis, yAxis=yAxis, zAxis=zAxis, axisSize=axisSize, backgroundColor=backgroundColor,
                                   marginLeft=marginLeft, marginRight=marginRight, marginTop=marginTop, marginBottom=marginBottom, tolerance=tolerance)
         Plotly.Show(fig, renderer=renderer, camera=camera, center=center, up=up, projection=projection)

topologicpy/Plotly.py

@@ -276,6 +276,7 @@ class Plotly:
                     sagitta: float = 0,
                     absolute: bool = False,
                     sides: int = 8,
+                    angle: float = 0,
                     vertexColor: str = "black",
                     vertexSize: float = 6,
                     vertexLabelKey: str = None,
@@ -454,6 +455,9 @@ class Plotly:
                     d = Topology.Dictionary(edge)
                     arc = Wire.ArcByEdge(edge, sagitta=sagitta, absolute=absolute, sides=sides, close=False, silent=silent)
                     if Topology.IsInstance(arc, "Wire"):
+                        if not angle == 0:
+                            direc = Edge.Direction(edge)
+                            arc = Topology.Rotate(arc, origin=Topology.Centroid(edge), axis=direc, angle=angle)
                         arc_edges = Topology.Edges(arc)
                         for arc_edge in arc_edges:
                             arc_edge = Topology.SetDictionary(arc_edge, d, silent=True)

topologicpy/Wire.py

@@ -1076,6 +1076,223 @@ class Wire():
         new_wire = Topology.SelfMerge(Topology.ByGeometry(vertices=g_vertices, edges=g_edges, faces=[]))
         return new_wire
 
+
+
+    @staticmethod
+    def ConcaveHull(topology, k: int = 3, mantissa: int = 6, tolerance: float = 0.0001):
+        """
+        Returns a wire representing the 2D convex hull of the input topology. The vertices of the topology are assumed to be coplanar.
+        Code based on Moreira, A and Santos, M Y, "CONCAVE HULL: A K-NEAREST NEIGHBOURS APPROACH FOR THE COMPUTATION OF THE REGION OCCUPIED BY A SET OF POINTS"
+        GRAPP 2007 - International Conference on Computer Graphics Theory and Applications.
+
+        Parameters
+        ----------
+        topology : topologic_core.Topology
+            The input topology.
+        k : int, optional
+            The number of nearest neighbors to consider for each point when building the hull. 
+            Must be at least 3 for the algorithm to function correctly. Increasing `k` will produce a smoother, 
+            less concave hull, while decreasing `k` may yield a more detailed, concave shape. The default is 3.
+        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
+        -------
+        topologic_core.Wire
+            The convex hull of the input topology.
+        """
+
+        from topologicpy.Vertex import Vertex
+        from topologicpy.Face import Face
+        from topologicpy.Topology import Topology
+        from math import atan2, sqrt, pi
+        from random import sample
+
+        # Helper function to clean the list by removing duplicate points
+        def clean_list(points_list):
+            return list(set(points_list))
+
+        # Helper function to find the point with the minimum Y-coordinate
+        def find_min_y_point(points):
+            return min(points, key=lambda p: [p[1], p[0]])
+
+        # Helper function to find the k-nearest neighbors to a given point
+        def nearest_points(points, reference_point, k):
+            # Sort points by distance from the reference point and select the first k points
+            sorted_points = sorted(points, key=lambda p: sqrt((p[0] - reference_point[0]) ** 2 + (p[1] - reference_point[1]) ** 2))
+            return sorted_points[:k]
+
+        # Helper function to sort points by the angle relative to the previous direction
+        def sort_by_angle(points, current_point, prev_angle):
+            def angle_to(p):
+                angle = atan2(p[1] - current_point[1], p[0] - current_point[0])
+                angle_diff = (angle - prev_angle + 2 * pi) % (2 * pi)
+                return angle_diff
+            return sorted(points, key=angle_to)
+
+        # Helper function to check if two line segments intersect
+        def intersects_q(line1, line2):
+            def orientation(p, q, r):
+                val = (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1])
+                if val == 0: return 0
+                return 1 if val > 0 else 2
+
+            p1, q1 = line1
+            p2, q2 = line2
+            o1 = orientation(p1, q1, p2)
+            o2 = orientation(p1, q1, q2)
+            o3 = orientation(p2, q2, p1)
+            o4 = orientation(p2, q2, q1)
+
+            if o1 != o2 and o3 != o4:
+                return True
+            if o1 == 0 and on_segment(p1, p2, q1): return True
+            if o2 == 0 and on_segment(p1, q2, q1): return True
+            if o3 == 0 and on_segment(p2, p1, q2): return True
+            if o4 == 0 and on_segment(p2, q1, q2): return True
+            return False
+
+        # Helper function to check if point q lies on segment pr
+        def on_segment(p, q, r):
+            return (q[0] <= max(p[0], r[0]) and q[0] >= min(p[0], r[0]) and
+                    q[1] <= max(p[1], r[1]) and q[1] >= min(p[1], r[1]))
+
+        # Helper function to calculate the angle between two points
+        def angle(p1, p2):
+            return atan2(p2[1] - p1[1], p2[0] - p1[0])
+
+        # Helper function to determine if a point is inside a polygon (Ray Casting method)
+        def point_in_polygon_q(point, polygon):
+            x, y = point
+            inside = False
+            n = len(polygon)
+            p1x, p1y = polygon[0]
+            for i in range(1, n + 1):
+                p2x, p2y = polygon[i % n]
+                if min(p1y, p2y) < y <= max(p1y, p2y) and x <= max(p1x, p2x):
+                    if p1y != p2y:
+                        xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                    if p1x == p2x or x <= xinters:
+                        inside = not inside
+                p1x, p1y = p2x, p2y
+            return inside
+
+        def concave_hull(points_list, k: int = 3):
+            # Ensure k >= 3
+            kk = max(k, 3)
+            
+            # Remove duplicate points
+            dataset = clean_list(points_list)
+            
+            # If there are fewer than 3 unique points, no polygon can be formed
+            if len(dataset) < 3:
+                return None
+            elif len(dataset) == 3:
+                return dataset  # If exactly 3 points, they form the polygon
+
+            # Ensure we have enough neighbors
+            kk = min(kk, len(dataset) - 1)
+            
+            # Find starting point (minimum Y value) and initialize hull
+            first_point = find_min_y_point(dataset)
+            hull = [first_point]
+            current_point = first_point
+            dataset.remove(first_point)
+            prev_angle = 0
+            step = 2
+            
+            # Original code logic, with an update to calculate prev_angle
+            while (current_point != first_point or step == 2) and len(dataset) > 0:
+                # After 4 steps, re-add the starting point to check for closure
+                if step == 5:
+                    dataset.append(first_point)
+                
+                # Find the k-nearest points
+                k_nearest_points = nearest_points(dataset, current_point, kk)
+                
+                # Sort candidates based on angle
+                c_points = sort_by_angle(k_nearest_points, current_point, prev_angle)
+                
+                intersection_found = True
+                i = 0
+                
+                # Select the first candidate that does not intersect any polygon edges
+                while intersection_found and i < len(c_points):
+                    candidate_point = c_points[i]
+                    i += 1
+                    
+                    if candidate_point == first_point:
+                        last_point_check = 1
+                    else:
+                        last_point_check = 0
+
+                    # Check for intersections with the existing edges
+                    j = 2
+                    intersection_found = False
+                    while not intersection_found and j < len(hull) - last_point_check:
+                        # Using hull[-1] and hull[-2] for last and second-to-last points
+                        intersection_found = intersects_q(
+                            (hull[-1], candidate_point),
+                            (hull[-1 - j], hull[-j])
+                        )
+                        j += 1
+
+                # If all candidates intersect, retry with a higher number of neighbors
+                if intersection_found:
+                    return concave_hull(points_list, kk + 1)
+                
+                # Update the hull with the selected candidate point
+                current_point = candidate_point
+                hull.append(current_point)
+
+                # Calculate the angle between the last two points in the hull to set `prev_angle`
+                if len(hull) > 1:
+                    prev_angle = angle(hull[-1], hull[-2])
+                    
+                dataset.remove(current_point)
+                step += 1
+
+
+            # Check if all points are inside the constructed hull
+            all_inside = True
+            i = len(dataset) - 1
+            while all_inside and i >= 0:
+                all_inside = point_in_polygon_q(dataset[i], hull)
+                i -= 1
+
+            # If any points are outside the hull, retry with a higher number of neighbors
+            if not all_inside:
+                return concave_hull(points_list, kk + 1)
+            
+            # Return the completed hull if all points are inside
+            return hull
+
+        f = None
+        # Create a sample face and flatten
+        while not Topology.IsInstance(f, "Face"):
+            vertices = Topology.SubTopologies(topology=topology, subTopologyType="vertex")
+            v = sample(vertices, 3)
+            w = Wire.ByVertices(v)
+            f = Face.ByWire(w, tolerance=tolerance, silent=True)
+            if not f == None:
+                origin = Topology.Centroid(f)
+                normal = Face.Normal(f, mantissa=mantissa)
+                f = Topology.Flatten(f, origin=origin, direction=normal)
+        flat_topology = Topology.Flatten(topology, origin=origin, direction=normal)
+        vertices = Topology.Vertices(flat_topology)
+        points = []
+        for v in vertices:
+            points.append((Vertex.X(v, mantissa=mantissa), Vertex.Y(v, mantissa=mantissa)))
+        hull = concave_hull(points, k=k)
+        hull_vertices = []
+        for p in hull:
+            hull_vertices.append(Vertex.ByCoordinates(p[0], p[1], 0))
+        ch = Wire.ByVertices(hull_vertices, close=True)
+        ch = Topology.Unflatten(ch, origin=origin, direction=normal)
+        return ch
+
     @staticmethod
     def ConvexHull(topology, mantissa: int = 6, tolerance: float = 0.0001):
         """
@@ -1197,8 +1414,8 @@ class Wire():
             origin = Topology.Centroid(f)
             normal = Face.Normal(f, mantissa=mantissa)
             f = Topology.Flatten(f, origin=origin, direction=normal)
-        topology = Topology.Flatten(topology, origin=origin, direction=normal)
-        vertices = Topology.Vertices(topology)
+        flat_topology = Topology.Flatten(topology, origin=origin, direction=normal)
+        vertices = Topology.Vertices(flat_topology)
         points = []
         for v in vertices:
             points.append((Vertex.X(v, mantissa=mantissa), Vertex.Y(v, mantissa=mantissa)))

topologicpy/version.py

@@ -1 +1 @@
-__version__ = '0.7.68'
+__version__ = '0.7.70'

{topologicpy-0.7.68.dist-info → topologicpy-0.7.70.dist-info}/METADATA

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

@@ -11,13 +11,13 @@ topologicpy/Dictionary.py,sha256=cURg452wwk2WeSxWY46ncgAUo5XD1c2c5EtO6ESZHaY,273
 topologicpy/Edge.py,sha256=--D035FBJa9hfPSPrPsNQluq1NHx7d3IGnklxbH-9qo,66928
 topologicpy/EnergyModel.py,sha256=AqTtmXE35SxvRXhG3vYAQd7GQDW-6HtjYPHua6ME4Eg,53762
 topologicpy/Face.py,sha256=vKtqoXmxLCC23QNg7Mk5PfFZACnbKh04vWRDoFCz1jw,124344
-topologicpy/Graph.py,sha256=fxoeDCxrcLyWoLPF5fGLt55KECYLVxsfKpDwS-qrc4k,385300
+topologicpy/Graph.py,sha256=CfyYvm-oFCURM3XpctekI-4qsOG2B6lZxgjD3WZlysQ,385478
 topologicpy/Grid.py,sha256=9N6PE84qCm40TRi2WtlVZSBwXXr47zHpscEpZHg_JW4,18205
 topologicpy/Helper.py,sha256=i-AfI29NMsZXBaymjilfvxQbuS3wpYbpPw4RWu1YCHs,16358
 topologicpy/Honeybee.py,sha256=HfTaEV1R8K1xOVQQy9sBOhBTF_ap8A2RxZOYhirp_Mw,21835
 topologicpy/Matrix.py,sha256=umgR7An919-wGInXJ1wpqnoQ2jCPdyMe2rcWTZ16upk,8079
 topologicpy/Neo4j.py,sha256=t52hgE9cVsqkGc7m7fjRsLnyfRHakVHwdvF4ms7ow78,22342
-topologicpy/Plotly.py,sha256=I67uOdeiH8-cKK0OUbKghJDGTP225H5-3Vtijyosvfk,109535
+topologicpy/Plotly.py,sha256=cs0LBOVm6WerT_F4IcFvQSRq_fYB9eVwRKiH2ogBgAI,109785
 topologicpy/Polyskel.py,sha256=EFsuh2EwQJGPLiFUjvtXmAwdX-A4r_DxP5hF7Qd3PaU,19829
 topologicpy/PyG.py,sha256=LU9LCCzjxGPUM31qbaJXZsTvniTtgugxJY7y612t4A4,109757
 topologicpy/Shell.py,sha256=CyMXuHoua_-lGGOr-1bgZa1VGpNsBGOe-dmkwhek-xY,87639
@@ -26,11 +26,11 @@ topologicpy/Sun.py,sha256=42tDWMYpwRG7Z2Qjtp94eRgBuqySq7k8TgNUZDK7QxQ,36837
 topologicpy/Topology.py,sha256=9DPTumt9kr9Su5b3RE8l_gLQSRalYHqf79tVHiy_aQM,400055
 topologicpy/Vector.py,sha256=A1g83zDHep58iVPY8WQ8iHNrSOfGWFEzvVeDuMnjDNY,33078
 topologicpy/Vertex.py,sha256=ZS6xK89JKokBKc0W8frdRhhuzR8c-dI1TTLt7pTf1iA,71032
-topologicpy/Wire.py,sha256=rThgAyePNkNR6LlX0lgEJZFWo7EEads1V9JdGDlZg7s,172596
+topologicpy/Wire.py,sha256=LMJWcrRWtK0spuyODYANy6442lF7g-fi0KNVqcbYtJo,182071
 topologicpy/__init__.py,sha256=vlPCanUbxe5NifC4pHcnhSzkmmYcs_UrZrTlVMsxcFs,928
-topologicpy/version.py,sha256=TQcBZ_0LJ13NMY5YrTufxmektelSYqtqEEsvl1QxCJE,23
-topologicpy-0.7.68.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
-topologicpy-0.7.68.dist-info/METADATA,sha256=pbI5CtiVUC2x6-LBgOhjVamnGJ9iybk_z18VcENQvJ8,10493
-topologicpy-0.7.68.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-topologicpy-0.7.68.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
-topologicpy-0.7.68.dist-info/RECORD,,
+topologicpy/version.py,sha256=B5ePMOWR_K7KFKMxVTSXxzaIt_LfFfLJBoG_ivXNV4A,23
+topologicpy-0.7.70.dist-info/LICENSE,sha256=FK0vJ73LuE8PYJAn7LutsReWR47-Ooovw2dnRe5yV6Q,681
+topologicpy-0.7.70.dist-info/METADATA,sha256=sLG6R02M67ZtwLMcLs5dr-LiogkrAfuSoM4GUJa8vKw,10493
+topologicpy-0.7.70.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+topologicpy-0.7.70.dist-info/top_level.txt,sha256=J30bDzW92Ob7hw3zA8V34Jlp-vvsfIkGzkr8sqvb4Uw,12
+topologicpy-0.7.70.dist-info/RECORD,,