flkit 0.1.0__py3-none-any.whl

flkit/alg/delaunay_triangulation.py

@@ -0,0 +1,476 @@
+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._key_precision = 8
+        self.ori_bound = {self._round_key(b): b for b in bound}
+        self.ori_points = {}
+        self.__points = []
+        self.__triangles = []
+
+    def _round_key(self, p):
+        return (
+            round(float(p[0]), self._key_precision),
+            round(float(p[1]), self._key_precision),
+        )
+
+    def unique_points(self, points):
+        """
+        去除点云中的重复点。
+
+        参数:
+            points: 点云数据列表 [[x1,y1], [x2,y2], ...]
+        """
+        seen = set()
+        unique_pts = []
+        for p in points:
+            key = (float(p[0]), float(p[1]))
+            if key not in seen:
+                seen.add(key)
+                unique_pts.append(p)
+        return unique_pts
+
+    def group_unique(self, target, source):
+        """去除target中与source重复的点"""
+        seen = set((float(p[0]), float(p[1])) for p in source)
+        return [p for p in target if (float(p[0]), float(p[1])) not in seen]
+
+    @property
+    def bound(self):
+        # 返回原始三维边界点（带 z），而不是键
+        return [pt for pt in self.ori_bound.values()]
+
+    @property
+    def points(self):
+        all_points = []
+        # 快速访问映射（边界+内部）
+        lookup = {}
+        lookup.update(self.ori_bound)
+        lookup.update(self.ori_points)
+        for idx, p in enumerate(self.__points):
+            key_point = self._round_key(p)
+            point = lookup.get(key_point)
+            # print(p, key_point, point)
+            if point is None:
+                raise ValueError(f"{point} 不在点集中")
+            all_points.append(point)
+        return all_points
+
+    @property
+    def triangles(self):
+        return self.__triangles
+
+    def add_points(self, points):
+        """
+        添加内部点云数据。
+
+        参数:
+            points: 内部点云数据列表 [[x1,y1], [x2,y2], ...]
+        """
+        points = self.unique_points(points)
+        self.ori_points = {self._round_key(p): p for p in points}
+        points_new = []
+        polygon = [key for key in self.ori_bound]
+        if polygon[0] != polygon[-1]:
+            polygon.append(polygon[0])
+        for p, value in self.ori_points.items():
+            if point_in_polygon(p, polygon)[0] not in [0, 1]:
+                continue
+            points_new.append((p, value))
+        self.ori_points = {p[0]: p[1] for p in points_new if p[0] not in self.ori_bound}
+
+        boundary_2d = np.array([key for key in self.ori_bound], dtype=float)
+        cloud_2d = np.array([key for key in self.ori_points], 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", switches="p"
+    ):
+        """
+        对点云数据生成带边界约束的三角网
+
+        参数:
+            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 = switches
+        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

flkit/alg/finite_plane_distance.py

@@ -0,0 +1,239 @@
+"""
+有限平面距离计算模块
+处理四个三维点确定的有限平面，计算点到平面的距离和位置判断
+"""
+
+import math
+import numpy as np
+from typing import Tuple, Optional
+from scipy.spatial import ConvexHull
+
+
+def comp_sliding_diff(d_h: float, angle: float, qj: float) -> list[float]:
+    """
+    计算点沿倾斜平面移动后的XY坐标差值
+
+    根据给定的高差、倾向角和倾角，计算点在平面上的位移。
+    适用于地质断层分析、滑坡计算等应用场景。
+    """
+    d_x = d_h * math.tan(qj / 180 * math.pi) * math.sin(angle / 180 * math.pi)
+    d_y = d_h * math.tan(qj / 180 * math.pi) * math.cos(angle / 180 * math.pi)
+
+    return [d_x, d_y]
+
+
+def finite_plane_distance(
+    point: np.ndarray, plane_points: np.ndarray, check_projection: bool = True
+) -> Tuple[float, int, bool, Optional[np.ndarray]]:
+    """
+    计算点到有限平面的距离和位置关系
+
+    Args:
+        point: 目标点 [x, y, z]
+        plane_points: 确定平面的四个点，形状为 (4, 3)
+        check_projection: 是否检查投影点是否在平面范围内
+
+    Returns:
+        Tuple[float, int, bool, Optional[np.ndarray]]:
+        - 垂直距离: 点到平面的垂直距离
+        - 侧面标识: 1表示正法向量方向，-1表示负法向量方向，0表示在平面上
+        - 在范围内: 投影点是否在有限平面范围内
+        - 投影点: 点在平面上的投影坐标，如果不在范围内则为None
+    """
+    if len(plane_points) != 4:
+        raise ValueError("需要恰好4个点来确定有限平面")
+
+    # 1. 计算平面方程
+    plane_normal, plane_d = _calculate_plane_equation(plane_points)
+
+    # 2. 计算垂直距离和侧面
+    vertical_distance, side = _calculate_vertical_distance(point, plane_normal, plane_d)
+
+    # 3. 计算投影点
+    projection_point = _calculate_projection_point(point, plane_normal, plane_d)
+
+    # 4. 检查投影点是否在有限平面范围内
+    if check_projection:
+        is_inside = _is_point_inside_finite_plane(
+            projection_point, plane_points, plane_normal
+        )
+        if not is_inside:
+            projection_point = None
+    else:
+        is_inside = True
+
+    return vertical_distance, side, is_inside, projection_point
+
+
+def finite_plane_closest_distance(
+    point: np.ndarray, plane_points: np.ndarray
+) -> Tuple[float, np.ndarray, str]:
+    """计算点到有限平面的最短距离（考虑边界）"""
+    vertical_distance, side, is_inside, projection_point = finite_plane_distance(
+        point, plane_points, check_projection=True
+    )
+
+    if is_inside:
+        return vertical_distance, projection_point, "vertical"
+    min_distance = float("inf")
+    closest_point = None
+    distance_type = "edge"
+
+    for i in range(4):
+        j = (i + 1) % 4
+        edge_start = plane_points[i]
+        edge_end = plane_points[j]
+
+        # 计算点到线段的距离
+        edge_distance, edge_closest = _point_to_line_segment_distance(
+            point, edge_start, edge_end
+        )
+
+        if edge_distance < min_distance:
+            min_distance = edge_distance
+            closest_point = edge_closest
+            distance_type = "edge"
+
+    for vertex in plane_points:
+        vertex_distance = np.linalg.norm(point - vertex)
+        if vertex_distance < min_distance:
+            min_distance = vertex_distance
+            closest_point = vertex
+            distance_type = "vertex"
+
+    return round(min_distance, 3), closest_point, distance_type
+
+
+def _calculate_plane_equation(plane_points: np.ndarray) -> Tuple[np.ndarray, float]:
+    """计算平面方程的法向量和常数项"""
+    p1, p2, p3 = plane_points[0], plane_points[1], plane_points[2]
+
+    v1 = p2 - p1
+    v2 = p3 - p1
+
+    normal = np.cross(v1, v2)
+
+    if np.allclose(normal, 0):
+        raise ValueError("给定的点共线，无法确定平面")
+
+    normal = normal / np.linalg.norm(normal)
+
+    d = -np.dot(normal, p1)
+
+    return normal, d
+
+
+def _calculate_vertical_distance(
+    point: np.ndarray, plane_normal: np.ndarray, plane_d: float
+) -> Tuple[float, int]:
+    """计算点到平面的垂直距离和侧面"""
+    signed_distance = np.dot(plane_normal, point) + plane_d
+
+    vertical_distance = abs(signed_distance)
+
+    if abs(signed_distance) < 1e-10:
+        side = 0
+    elif signed_distance > 0:
+        side = 1
+    else:
+        side = -1
+
+    return round(vertical_distance, 3), side
+
+
+def _calculate_projection_point(
+    point: np.ndarray, plane_normal: np.ndarray, plane_d: float
+) -> np.ndarray:
+    """计算点在平面上的投影"""
+    signed_distance = np.dot(plane_normal, point) + plane_d
+
+    projection = point - signed_distance * plane_normal
+
+    return projection
+
+
+def _is_point_inside_finite_plane(
+    point: np.ndarray, plane_points: np.ndarray, plane_normal: np.ndarray
+) -> bool:
+    """判断点是否在有限平面范围内"""
+    try:
+        if abs(plane_normal[2]) < 0.9:
+            u = np.cross(plane_normal, [0, 0, 1])
+        else:
+            u = np.cross(plane_normal, [1, 0, 0])
+        u = u / np.linalg.norm(u)
+        v = np.cross(plane_normal, u)
+        v = v / np.linalg.norm(v)
+
+        plane_2d = np.column_stack([np.dot(plane_points, u), np.dot(plane_points, v)])
+        point_2d = np.array([np.dot(point, u), np.dot(point, v)])
+
+        hull = ConvexHull(plane_2d)
+        return _point_in_convex_polygon(point_2d, plane_2d[hull.vertices])
+
+    except Exception:
+        return _point_in_quadrilateral_simple(point, plane_points, plane_normal)
+
+
+def _point_in_convex_polygon(point: np.ndarray, polygon: np.ndarray) -> bool:
+    """判断点是否在凸多边形内（2D）"""
+    n = len(polygon)
+    for i in range(n):
+        j = (i + 1) % n
+        cross = np.cross(polygon[j] - polygon[i], point - polygon[i])
+        if cross < 0:
+            return False
+    return True
+
+
+def _point_in_quadrilateral_simple(
+    point: np.ndarray, plane_points: np.ndarray, plane_normal: np.ndarray
+) -> bool:
+    """简单的四边形内点判断"""
+    signs = []
+
+    for i in range(4):
+        j = (i + 1) % 4
+        edge_vector = plane_points[j] - plane_points[i]
+        to_point = point - plane_points[i]
+
+        cross = np.cross(edge_vector, to_point)
+        sign = np.dot(cross, plane_normal)
+        signs.append(sign)
+
+    positive = sum(1 for s in signs if s > 1e-10)
+    negative = sum(1 for s in signs if s < -1e-10)
+
+    return positive == 0 or negative == 0
+
+
+def _point_to_line_segment_distance(
+    point: np.ndarray, line_start: np.ndarray, line_end: np.ndarray
+) -> Tuple[float, np.ndarray]:
+    """计算点到线段的最短距离"""
+    line_vector = line_end - line_start
+    line_length_sq = np.dot(line_vector, line_vector)
+
+    if line_length_sq < 1e-10:
+        return np.linalg.norm(point - line_start), line_start
+
+    t = np.dot(point - line_start, line_vector) / line_length_sq
+
+    t = max(0, min(1, t))
+
+    closest_point = line_start + t * line_vector
+
+    distance = np.linalg.norm(point - closest_point)
+
+    return distance, closest_point
+
+
+def batch_finite_plane_distance(
+    points: np.ndarray, plane_points: np.ndarray, check_projection: bool = True
+) -> list:
+    """批量计算多个点到有限平面的距离"""
+    results = []
+    for point in points:
+        result = finite_plane_distance(point, plane_points, check_projection)
+        results.append(result)
+    return results