flkit 0.1.0__py3-none-any.whl

flkit/alg/get_up_low.py

@@ -0,0 +1,32 @@
+def get_up_low(target, data, label="value"):
+    """
+    二分查找目标值在有序数据中的上下界。
+    """
+    # 检查目标值是否在数据范围内
+    if target[label] < data[0][label]:
+        return (None, data[0])
+    if target[label] > data[-1][label]:
+        return (data[-1], None)
+
+    # 按照label升序排序
+    data = sorted(data, key=lambda x: x[label])
+
+    for idx, item in enumerate(data[:-1]):
+        if item[label] <= target[label] <= data[idx + 1][label]:
+            return (item, data[idx + 1])
+
+
+def linear_interpolation(target, up, low, scale="value", labels=("x", "y", "z")):
+    """
+    线性插值计算目标值在有序数据中的上下界。
+    """
+    if up is None or low is None:
+        return None
+
+    weight = (target[scale] - up[scale]) / (low[scale] - up[scale])
+
+    results = []
+    for label in labels:
+        results.append(up[label] + weight * (low[label] - up[label]))
+
+    return tuple(results)

flkit/alg/in_tin.py

@@ -0,0 +1,139 @@
+import numpy as np
+
+
+def point_to_triangle_distance(P, A, B, C):
+    """
+    计算点到三角形的距离和相关信息
+
+    参数:
+        P: 待测点 [x, y, z]
+        A, B, C: 三角形三个顶点 [x, y, z]
+
+    返回:
+        distance: 点到三角形的最小距离
+        projection: 垂足坐标
+        is_inside: 垂足是否在三角形内部
+        barycentric: 重心坐标 [u, v, w]
+    """
+
+    # 转换为numpy数组
+    P = np.array(P)
+    A = np.array(A)
+    B = np.array(B)
+    C = np.array(C)
+
+    # 计算平面法向量
+    AB = B - A
+    AC = C - A
+    normal = np.cross(AB, AC)
+
+    # 处理退化三角形的情况
+    if np.linalg.norm(normal) < 1e-10:
+        raise ValueError("三角形退化或面积为零")
+
+    # 计算点到平面的距离
+    AP = P - A
+    distance_to_plane = abs(np.dot(AP, normal)) / np.linalg.norm(normal)
+
+    # 计算垂足坐标
+    t = np.dot(AP, normal) / np.dot(normal, normal)
+    projection = P - t * normal
+
+    # 计算重心坐标
+    v0 = C - A
+    v1 = B - A
+    v2 = projection - A
+
+    d00 = np.dot(v0, v0)
+    d01 = np.dot(v0, v1)
+    d11 = np.dot(v1, v1)
+    d20 = np.dot(v2, v0)
+    d21 = np.dot(v2, v1)
+
+    denom = d00 * d11 - d01 * d01
+
+    # 处理数值精度问题
+    if abs(denom) < 1e-10:
+        v = w = 0
+        u = 1
+    else:
+        v = (d11 * d20 - d01 * d21) / denom
+        w = (d00 * d21 - d01 * d20) / denom
+        u = 1.0 - v - w
+
+    # 判断垂足是否在三角形内部
+    is_inside = (u >= -1e-10) and (v >= -1e-10) and (w >= -1e-10)
+
+    if is_inside:
+        # 垂足在三角形内，最小距离就是到平面的距离
+        min_distance = distance_to_plane
+    else:
+        # 垂足在三角形外，需要计算到三条边的最短距离
+        dist_AB = point_to_segment_distance(P, A, B)
+        dist_BC = point_to_segment_distance(P, B, C)
+        dist_CA = point_to_segment_distance(P, C, A)
+        min_distance = min(dist_AB, dist_BC, dist_CA)
+
+    return {
+        "distance": min_distance,
+        "projection": projection.tolist(),
+        "is_inside": is_inside,
+        "barycentric": [u, v, w],
+        "distance_to_plane": distance_to_plane,
+    }
+
+
+def point_to_segment_distance(P, A, B):
+    """计算点到线段的最短距离"""
+    P, A, B = np.array(P), np.array(A), np.array(B)
+
+    AB = B - A
+    AP = P - A
+
+    # 计算投影参数t
+    t = np.dot(AP, AB) / np.dot(AB, AB)
+
+    # 限制t在[0,1]范围内
+    t = max(0, min(1, t))
+
+    # 计算最近点
+    nearest_point = A + t * AB
+
+    # 返回距离
+    return np.linalg.norm(P - nearest_point)
+
+
+def is_point_in_triangle(P, A, B, C):
+    """判断点是否在三角形内部（使用重心坐标法）"""
+    A, B, C, P = np.array(A), np.array(B), np.array(C), np.array(P)
+
+    # 计算重心坐标
+    v0 = C - A
+    v1 = B - A
+    v2 = P - A
+
+    d00 = np.dot(v0, v0)
+    d01 = np.dot(v0, v1)
+    d11 = np.dot(v1, v1)
+    d20 = np.dot(v2, v0)
+    d21 = np.dot(v2, v1)
+
+    denom = d00 * d11 - d01 * d01
+
+    if abs(denom) < 1e-10:
+        return False
+
+    v = (d11 * d20 - d01 * d21) / denom
+    w = (d00 * d21 - d01 * d20) / denom
+    u = 1.0 - v - w
+
+    return (u >= -1e-10) and (v >= -1e-10) and (w >= -1e-10)
+
+
+def is_point_in_triangles(P, tins, range):
+    """判断点是否在多个三角形内部"""
+    for idx, tin in enumerate(tins):
+        result = is_point_in_triangle(P, tin[0], tin[1], tin[2])
+        if result["is_inside"] and result["distance"] <= range[idx]:
+            return 1, idx
+    return 0, -1

flkit/alg/index.py

@@ -0,0 +1,9 @@
+def list_index(lst, vals):
+    ids = []
+    for idx, val in enumerate(lst):
+        if val in vals:
+            ids.append(idx)
+    if len(ids) == 0:
+        return -1
+    else:
+        return ids[-1]

flkit/alg/inter/BasePredictor.py

@@ -0,0 +1,69 @@
+"""
+预测工具。这是一个接口用于定义预测器的基本功能。
+"""
+
+import pickle
+from bson import ObjectId
+from abc import abstractmethod
+
+
+class Predictor:
+    def __init__(self):
+        self.uid = ObjectId()
+        self.model = None
+        self.params = None
+
+    def save(self, file_path):
+        """
+        保存模型到文件
+        :param file_path: 文件路径
+        :return: None
+        """
+        with open(file_path, "wb") as file:
+            pickle.dump(self.model, file)
+
+    def load(self, file_path):
+        """
+        从文件加载模型
+        :param file_path: 文件路径
+        :return: None
+        """
+        with open(file_path, "rb") as file:
+            return pickle.load(file)
+
+    @abstractmethod
+    def predict(self, point):
+        """
+        预测目标点的属性值
+        :param point: 目标点坐标
+        :return: 预测值
+        """
+        pass
+
+    @abstractmethod
+    def loss(self, point):
+        """
+        计算预测值与实际值的损失
+        :param point: 目标点坐标
+        :return: 损失值
+        """
+        pass
+
+    def add_params(self, params):
+        """
+        添加预测器参数
+        :param params: 参数字典
+        :return: None
+        """
+        if params is None:
+            return
+        self.params = params
+
+    def reset(self):
+        """
+        重置预测器参数
+        :return: None
+        """
+        if self.params is None:
+            return
+        self.params = None

flkit/alg/inter/Kriging.py

@@ -0,0 +1,226 @@
+import numpy as np
+from pykrige.ok import OrdinaryKriging
+from pykrige.uk3d import UniversalKriging3D
+from pykrige.ok3d import OrdinaryKriging3D
+
+
+class Kriging2D:
+    """二维普通克里金插值"""
+
+    def __init__(self, variogram_model="spherical", nlags=20):
+        self.variogram_model = variogram_model
+        self.nlags = nlags
+        self.ok = None
+
+    def fit(self, xyzv: np.ndarray):
+        """
+        训练Kriging2D模型
+
+        Parameters:
+        -----------
+        xyzv : np.ndarray, shape (N, 3)
+            已知点数据，每行为 [x, y, z]，其中z为插值目标值
+
+        Returns:
+        --------
+        self : Kriging2D
+            返回自身以支持链式调用
+        """
+        xyzv = np.atleast_2d(xyzv)
+        if xyzv.shape[1] != 3:
+            raise ValueError("输入数据必须是3列：[x, y, z]")
+
+        self.ok = OrdinaryKriging(
+            xyzv[:, 0],
+            xyzv[:, 1],
+            xyzv[:, 2],
+            variogram_model=self.variogram_model,
+            nlags=self.nlags,
+            enable_plotting=False,
+        )
+        return self
+
+    def predict(self, xy: np.ndarray):
+        """
+        在指定位置进行预测
+
+        Parameters:
+        -----------
+        xy : np.ndarray, shape (M, 2) or (2,)
+            待插值点的坐标 [x, y]
+
+        Returns:
+        --------
+        float or np.ndarray
+            - 单点输入 (2,): 返回标量值
+            - 多点输入 (M, 2): 返回数组 shape (M,)
+        """
+        # 检查输入是单点还是多点
+        is_single_point = xy.ndim == 1 or (xy.ndim == 2 and xy.shape[0] == 1)
+
+        xy = np.atleast_2d(xy)
+        z, _ = self.ok.execute("points", xy[:, 0], xy[:, 1])
+
+        # 根据输入类型返回相应格式
+        if is_single_point:
+            return float(z[0])  # 单点返回标量
+        else:
+            return z  # 多点返回数组
+
+
+class Kriging3DUn:
+    """三维泛克里金插值"""
+
+    def __init__(self, variogram_model="spherical", nlags=20):
+        self.variogram_model = variogram_model
+        self.nlags = nlags
+        self.uk3d = None
+
+    def fit(self, xyzv: np.ndarray):
+        """
+        xyzv: (N,4) 每行 [x,y,z,value]
+        """
+        self.uk3d = UniversalKriging3D(
+            xyzv[:, 0],
+            xyzv[:, 1],
+            xyzv[:, 2],
+            xyzv[:, 3],
+            variogram_model=self.variogram_model,
+            nlags=self.nlags,
+            enable_plotting=False,
+        )
+        return self
+
+    def predict(self, xyz: np.ndarray):
+        """
+        在指定位置进行预测
+
+        Parameters:
+        -----------
+        xyz : np.ndarray, shape (M, 3) or (3,)
+            待插值点的坐标 [x, y, z]
+
+        Returns:
+        --------
+        float or np.ndarray
+            - 单点输入 (3,): 返回标量值
+            - 多点输入 (M, 3): 返回数组 shape (M,)
+        """
+        # 检查输入是单点还是多点
+        is_single_point = xyz.ndim == 1 or (xyz.ndim == 2 and xyz.shape[0] == 1)
+
+        xyz = np.atleast_2d(xyz)
+        v, _ = self.uk3d.execute("points", xyz[:, 0], xyz[:, 1], xyz[:, 2])
+
+        # 根据输入类型返回相应格式
+        if is_single_point:
+            return float(v[0])  # 单点返回标量
+        else:
+            return v  # 多点返回数组
+
+
+class Kriging3D:
+    """三维普通克里金插值"""
+
+    def __init__(self, variogram_model="spherical", nlags=20):
+        self.variogram_model = variogram_model
+        self.nlags = nlags
+        self.ok3d = None
+
+    def fit(self, xyzv: np.ndarray):
+        """
+        拟合3D普通克里金模型
+
+        Parameters:
+        -----------
+        xyzv: np.ndarray, shape (N, 4)
+            每行为 [x, y, z, value]，其中：
+            - x, y, z: 空间坐标
+            - value: 在该位置的观测值
+
+        Returns:
+        --------
+        self: Kriging3DUn
+            返回自身以支持链式调用
+        """
+        self.ok3d = OrdinaryKriging3D(
+            xyzv[:, 0],  # x坐标
+            xyzv[:, 1],  # y坐标
+            xyzv[:, 2],  # z坐标
+            xyzv[:, 3],  # 观测值
+            variogram_model=self.variogram_model,
+            nlags=self.nlags,
+            enable_plotting=False,
+        )
+        return self
+
+    def predict(self, xyz: np.ndarray):
+        """
+        在指定位置进行预测
+
+        Parameters:
+        -----------
+        xyz: np.ndarray, shape (N, 3) or (3,)
+            预测位置的坐标 [x, y, z]
+
+        Returns:
+        --------
+        float or np.ndarray
+            - 单点输入 (3,): 返回标量值
+            - 多点输入 (M, 3): 返回数组 shape (M,)
+        """
+        if self.ok3d is None:
+            raise ValueError("模型尚未拟合，请先调用 fit() 方法")
+
+        # 检查输入是单点还是多点
+        is_single_point = xyz.ndim == 1 or (xyz.ndim == 2 and xyz.shape[0] == 1)
+
+        xyz = np.atleast_2d(xyz)
+        v, _ = self.ok3d.execute("points", xyz[:, 0], xyz[:, 1], xyz[:, 2])
+
+        # 根据输入类型返回相应格式
+        if is_single_point:
+            return float(v[0])  # 单点返回标量
+        else:
+            return v  # 多点返回数组
+
+    def predict_grid(self, x_range, y_range, z_range, resolution=None):
+        """
+        在规则网格上进行预测
+
+        Parameters:
+        -----------
+        x_range: tuple
+            x方向的范围 (x_min, x_max)
+        y_range: tuple
+            y方向的范围 (y_min, y_max)
+        z_range: tuple
+            z方向的范围 (z_min, z_max)
+        resolution: tuple, optional
+            网格分辨率 (nx, ny, nz)，默认为 (50, 50, 50)
+
+        Returns:
+        --------
+        tuple
+            (grid_x, grid_y, grid_z, predictions)
+            - grid_x, grid_y, grid_z: 网格坐标
+            - predictions: 预测值网格
+        """
+        if self.ok3d is None:
+            raise ValueError("模型尚未拟合，请先调用 fit() 方法")
+
+        if resolution is None:
+            resolution = (50, 50, 50)
+
+        # 创建网格
+        x = np.linspace(x_range[0], x_range[1], resolution[0])
+        y = np.linspace(y_range[0], y_range[1], resolution[1])
+        z = np.linspace(z_range[0], z_range[1], resolution[2])
+
+        # 执行网格预测
+        predictions, _ = self.ok3d.execute("grid", x, y, z)
+
+        # 创建网格坐标
+        grid_x, grid_y, grid_z = np.meshgrid(x, y, z, indexing="ij")
+
+        return grid_x, grid_y, grid_z, predictions