flkit 0.1.0__py3-none-any.whl

flkit/alg/del2.py

@@ -0,0 +1,421 @@
+from typing import List
+import numpy as np
+import triangle as tr
+from scipy.spatial import ConvexHull
+
+
+def convex_hull_boundary(points):
+    """
+    使用凸包算法计算点云边界点
+    适用于寻找最外层的凸边界
+    """
+    points = np.asarray(points)
+    hull = ConvexHull(points[:, :2])
+    boundary_points = points[hull.vertices]
+    return boundary_points.tolist()
+
+
+def interpolate_delaunary_z(xy, triangle):
+    """
+    计算 Delaunary 三角形内一点xy的 z 坐标。
+
+    参数:
+        triangle: 长度为3的列表或元组，表示三角形三个顶点的 (x, y, z)
+        xy: 长度为2的列表或元组，表示待求点的 (x, y)
+    返回:
+        z: 插值得到的 z 坐标
+    """
+    x1, y1, z1 = triangle[0]
+    x2, y2, z2 = triangle[1]
+    x3, y3, z3 = triangle[2]
+    x, y = xy[:2]
+
+    # 计算两个边向量
+    ux, uy, uz = x2 - x1, y2 - y1, z2 - z1
+    vx, vy, vz = x3 - x1, y3 - y1, z3 - z1
+
+    # 计算法向量（叉积）
+    nx = uy * vz - uz * vy
+    ny = uz * vx - ux * vz
+    nz = ux * vy - uy * vx
+
+    # 检查三角形是否退化
+    if nx == 0 and ny == 0 and nz == 0:
+        raise ValueError("三点共线，无法构成三角形")
+
+    # 平面方程: nx*(X-x1) + ny*(Y-y1) + nz*(Z-z1) = 0
+    # 解出 Z
+    if nz == 0:
+        raise ValueError("三角形垂直于 xy 平面，无法由 xy 唯一确定 z")
+    z = z1 - (nx * (x - x1) + ny * (y - y1)) / nz
+    return z
+
+
+def bound_triangulation(points: List[List[float]]):
+    """
+    构建边界三角网：采用扇形三角剖分（0, i, i+1）。
+    假设边界为凸多边形；若为非凸，多边形需另行剖分。
+    """
+    n = len(points)
+    if n < 3:
+        return []
+    triangles = []
+    for i in range(1, n - 1):
+        triangles.append([0, i, i + 1])
+    return triangles
+
+
+def point_in_polygon(point, polygon, epsilon=1e-12):
+    """
+    简洁的射线法（奇偶规则），返回：
+      1  -> 内部
+      0  -> 边缘
+     -1  -> 外部
+
+    :param point: 点坐标
+    :param polygon: 多边形顶点坐标列表
+    :param epsilon: 浮点数精度
+    :return: 1/0/-1, (边索引1, 边索引2)
+    """
+    x, y = point[:2]
+    n = len(polygon)
+
+    # 先判断是否在边界上
+    for i in range(n):
+        x1, y1 = polygon[i][:2]
+        x2, y2 = polygon[(i + 1) % n][:2]
+
+        cross = (x - x1) * (y2 - y1) - (y - y1) * (x2 - x1)
+        if (
+            abs(cross) < epsilon
+            and min(x1, x2) - epsilon <= x <= max(x1, x2) + epsilon
+            and min(y1, y2) - epsilon <= y <= max(y1, y2) + epsilon
+        ):
+            # 返回该点所在的边索引
+            return 0, (i, (i + 1) % n)
+
+    # 射线法判断内外
+    inside = False
+    for i in range(n):
+        x1, y1 = polygon[i][:2]
+        x2, y2 = polygon[(i + 1) % n][:2]
+        if (y1 > y) != (y2 > y):
+            x_intersect = (x2 - x1) * (y - y1) / (y2 - y1) + x1
+            if x_intersect > x:
+                inside = not inside
+
+    return (1, (-1, -1)) if inside else (-1, (-1, -1))
+
+
+class DelaunayTriangulation:
+    """
+    Delaunay三角剖分类
+
+    >>> dt = DelaunayTriangulation([[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]])
+    >>> dt.add_point([0.5, 0.5])
+    True
+    >>> dt.triangles
+    [[0, 1, 2], [0, 2, 3], [0, 3, 4], [0, 4, 1], [1, 2, 5], [2, 3, 5], [3, 4, 5]]
+    >>> dt.add_point([0.25, 0.25])
+    True
+    >>> dt.triangles
+    [[0, 1, 2], [0, 2, 3], [0, 3, 4], [0, 4, 1], [1, 2, 5], [2, 3, 5], [3, 4, 5]]
+    """
+
+    def __init__(self, bound: List[List[float]]):
+        """
+        初始化Delaunay三角网
+
+        :param bound: 边界多边形顶点坐标列表
+        :param points: 内部点坐标列表
+
+        >>> dt = DelaunayTriangulation([[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]])
+        >>> dt.add_point([0.5, 0.5])
+        True
+        """
+        self.bound = bound
+        self.points = list(bound)
+        self.triangles = bound_triangulation(bound)
+
+    def add_point(self, point: List[float]):
+        """
+        添加内部点
+
+        :param point: 内部点坐标
+        """
+        # 先判断点是否在边界上
+        sign, _ = point_in_polygon(point, self.bound)
+        if sign == -1:
+            return False
+        # 检查点是否已存在
+        if point in self.points:
+            return False
+        self.points.append(point)
+        n_p_idx = len(self.points) - 1
+        # 查找包含点的三角形
+        # 如果点在边界上则将三角形拆分为2个三角形
+        for _, triangle in enumerate(self.triangles):
+            sign, edge = point_in_polygon(point, [self.points[idx] for idx in triangle])
+            if sign == 1:
+                # 点在内部，删除包含点的三角形，将其拆分为3个三角形
+                self.triangles.remove(triangle)
+                self.triangles.append([triangle[0], triangle[1], n_p_idx])
+                self.triangles.append([triangle[1], triangle[2], n_p_idx])
+                self.triangles.append([triangle[2], triangle[0], n_p_idx])
+                return True
+            elif sign == 0:
+                # 点在边界上，删除包含点的三角形，将其拆分为2个三角形
+                # 找到点所在的线的位置
+                self.triangles.remove(triangle)
+                if edge == (0, 1):
+                    # 在0-1之间，则拆分为1-2-n_p_idx；2-0-n_p_idx；
+                    self.triangles.append([triangle[1], triangle[2], n_p_idx])
+                    self.triangles.append([triangle[2], triangle[0], n_p_idx])
+                elif edge == (1, 2):
+                    # 在1-2之间，则拆分为0-1-n_p_idx；2-0-n_p_idx；
+                    self.triangles.append([triangle[0], triangle[1], n_p_idx])
+                    self.triangles.append([triangle[2], triangle[0], n_p_idx])
+                elif edge == (2, 0):
+                    # 在2-0之间，则拆分为0-1-n_p_idx；1-2-n_p_idx；
+                    self.triangles.append([triangle[0], triangle[1], n_p_idx])
+                    self.triangles.append([triangle[1], triangle[2], n_p_idx])
+                return True
+
+    def add_points(self, points: List[List[float]]):
+        """
+        添加内部点
+
+        :param points: 内部点坐标列表
+        """
+        for point in points:
+            self.add_point(point)
+
+
+class OptimizedDelaunayTriangulation(DelaunayTriangulation):
+    """
+    优化版 Delaunay 三角剖分类（继承自 DelaunayTriangulation）
+
+    在添加新点后，进行局部的边翻转优化，尽量减少钝角三角形。
+    优化策略基于“最大角度下降”原则：若翻转共享边后，两个相邻三角形的最大角度减小，则执行翻转。
+
+    用法示例：
+    >>> dt = OptimizedDelaunayTriangulation([[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]])
+    >>> dt.add_point([0.5, 0.5])
+    True
+    """
+
+    def add_point(self, point: List[float]):
+        """
+        添加内部点，并在添加后对新点邻域进行局部优化，减少钝角三角形。
+        """
+        inserted = super().add_point(point)
+        if not inserted:
+            return False
+        n_p_idx = len(self.points) - 1
+        self._optimize_around_point(n_p_idx)
+        return True
+
+    # ---------- 以下为局部优化所需的辅助函数 ----------
+    def _xy(self, idx):
+        p = self.points[idx]
+        return float(p[0]), float(p[1])
+
+    def _angle_at(self, a_idx, b_idx, c_idx, eps=1e-12):
+        import math
+
+        ax, ay = self._xy(a_idx)
+        bx, by = self._xy(b_idx)
+        cx, cy = self._xy(c_idx)
+        v1x, v1y = ax - bx, ay - by
+        v2x, v2y = cx - bx, cy - by
+        n1 = (v1x * v1x + v1y * v1y) ** 0.5
+        n2 = (v2x * v2x + v2y * v2y) ** 0.5
+        if n1 < eps or n2 < eps:
+            return 0.0
+        cos_val = (v1x * v2x + v1y * v2y) / (n1 * n2)
+        if cos_val < -1.0:
+            cos_val = -1.0
+        elif cos_val > 1.0:
+            cos_val = 1.0
+        return math.degrees(math.acos(cos_val))
+
+    def _max_angle(self, tri):
+        a, b, c = tri
+        return max(
+            self._angle_at(b, a, c),
+            self._angle_at(a, b, c),
+            self._angle_at(a, c, b),
+        )
+
+    def _find_adjacent_triangle_edge(self, i, j, exclude_triangle):
+        # 查找共享边(i, j)的另一侧三角形
+        for t in self.triangles:
+            if t is exclude_triangle:
+                continue
+            if i in t and j in t:
+                return t
+        return None
+
+    def _degenerate(self, tri, eps=1e-12):
+        ax, ay = self._xy(tri[0])
+        bx, by = self._xy(tri[1])
+        cx, cy = self._xy(tri[2])
+        area2 = abs((bx - ax) * (cy - ay) - (by - ay) * (cx - ax))
+        return area2 < eps
+
+    def _should_flip_by_angle(self, p, a, b, c, margin=1e-9):
+        # 翻转判据：翻转后两个三角形的“最大角”更小
+        old1 = [p, a, b]
+        old2 = [p, a, c]
+        new1 = [p, b, c]
+        new2 = [a, b, c]
+        # 避免翻转后出现退化三角形
+        if self._degenerate(new1) or self._degenerate(new2):
+            return False
+        old_max = max(self._max_angle(old1), self._max_angle(old2))
+        new_max = max(self._max_angle(new1), self._max_angle(new2))
+        return new_max + margin < old_max
+
+    def _optimize_around_point(self, p_idx, max_iterations=100):
+        """
+        以新插入点为中心，对其相邻边执行局部边翻转，
+        若翻转能降低相邻两三角形的最大角度，则执行翻转。
+        """
+        iterations = 0
+        changed = True
+        while changed and iterations < max_iterations:
+            iterations += 1
+            changed = False
+            triangles_with_p = [t for t in self.triangles if p_idx in t]
+            for t1 in triangles_with_p:
+                # t1 = [p_idx, a, b]
+                ab = [v for v in t1 if v != p_idx]
+                if len(ab) != 2:
+                    continue
+                for a in ab:
+                    b = ab[0] if a == ab[1] else ab[1]
+                    neighbor = self._find_adjacent_triangle_edge(
+                        p_idx, a, exclude_triangle=t1
+                    )
+                    if neighbor is None:
+                        continue
+                    # neighbor = [p_idx, a, c]
+                    c_candidates = [v for v in neighbor if v != p_idx and v != a]
+                    if len(c_candidates) != 1:
+                        continue
+                    c = c_candidates[0]
+                    if self._should_flip_by_angle(p_idx, a, b, c):
+                        # 执行边翻转：移除旧三角形，加入新三角形
+                        try:
+                            self.triangles.remove(t1)
+                        except ValueError:
+                            pass
+                        try:
+                            self.triangles.remove(neighbor)
+                        except ValueError:
+                            pass
+                        self.triangles.append([p_idx, b, c])
+                        self.triangles.append([a, b, c])
+                        changed = True
+                        break
+                if changed:
+                    break
+
+
+class TriangleLibTriangulation:
+    """
+    基于Triangle库的Delaunay三角剖分。
+    """
+
+    def __init__(self, bound):
+        """
+        初始化三角网。
+
+        参数:
+            boundary: 边界点列表，格式为[(x1,y1), (x2,y2), ...]
+        """
+        self.bound = np.asarray(bound).tolist()
+
+    def add_points(self, points):
+        """
+        添加内部点云数据。
+
+        参数:
+            points: 内部点云数据列表 [[x1,y1], [x2,y2], ...]
+        """
+        boundary_arr = np.array(self.bound)
+        points_arr = np.array(points)
+
+        boundary_xy = set((float(b[0]), float(b[1])) for b in boundary_arr)
+        filtered_points = [
+            p.tolist() if isinstance(p, np.ndarray) else list(p)
+            for p in points_arr
+            if (float(p[0]), float(p[1])) not in boundary_xy
+        ]
+
+        boundary_2d = boundary_arr[:, :2]
+        cloud_2d = (
+            np.array(filtered_points, dtype=float)[:, :2]
+            if len(filtered_points) > 0
+            else np.empty((0, 2), dtype=float)
+        )
+
+        result = self.point_cloud_triangulation(boundary_2d, cloud_2d)
+
+        vertices = result.get("vertices")
+        triangles = result.get("triangles", [])
+        if vertices is None:
+            vertices = np.vstack([boundary_2d, cloud_2d])
+        self.points = vertices.tolist()
+        self.triangles = (
+            triangles.tolist() if isinstance(triangles, np.ndarray) else triangles
+        )
+        return result
+
+    def point_cloud_triangulation(
+        self, boundary_points, cloud_points, quality_params="pq20a0.001"
+    ):
+        """
+        对点云数据生成带边界约束的三角网
+
+        参数:
+            boundary_points: 边界点列表 [[x1,y1], [x2,y2], ...]
+            cloud_points: 内部点云数据列表
+            quality_params: 三角化质量参数
+        """
+        # 合并所有点
+        boundary_points = np.array(boundary_points, dtype=float)
+        cloud_points = np.array(cloud_points, dtype=float)
+        if cloud_points.size == 0:
+            all_points = boundary_points
+        else:
+            all_points = np.vstack([boundary_points, cloud_points])
+        n_boundary = len(boundary_points)
+
+        # 创建边界段（连接边界点）
+        segments = []
+        for i in range(n_boundary):
+            segments.append([i, (i + 1) % n_boundary])  # 确保边界闭合
+
+        # 准备输入数据
+        # Normalize coordinates to improve numerical stability
+        bbox_min = np.min(all_points, axis=0)
+        bbox_max = np.max(all_points, axis=0)
+        center = (bbox_min + bbox_max) / 2.0
+        scale = max(bbox_max[0] - bbox_min[0], bbox_max[1] - bbox_min[1])
+        if scale == 0:
+            scale = 1.0
+        norm_points = (all_points - center) / scale
+        mesh_data = {"vertices": norm_points, "segments": segments}
+        # 执行三角化（带约束和质量控制）
+        # 组合开关：p(约束) + 质量参数 + D(Delaunay)
+        switches = "pD"
+        result = tr.triangulate(mesh_data, switches)
+
+        # De-normalize vertices back to original coordinate scale
+        verts = result.get("vertices")
+        if verts is not None:
+            verts = np.asarray(verts, dtype=float)
+            result["vertices"] = verts * scale + center
+
+        return result