flkit 0.1.0__py3-none-any.whl

flkit/alg/inter/rbf.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+径向基函数插值算法实现
+Radial Basis Function (RBF) Interpolation
+
+RBF是一种基于径向基函数的插值方法，具有良好的数学性质。
+支持多种核函数，适用于复杂的非线性插值问题。
+"""
+
+import numpy as np
+from scipy.interpolate import Rbf
+from scipy.spatial.distance import cdist
+
+
+class RBF2D:
+    """
+    二维径向基函数插值
+
+    支持多种径向基函数，适用于复杂地形插值
+    """
+
+    def __init__(self, function="multiquadric", epsilon=None, smooth=0.0):
+        """
+        初始化RBF2D插值器
+
+        Parameters:
+        -----------
+        function : str, default='multiquadric'
+            径向基函数类型，可选：
+            - 'multiquadric': sqrt((r/epsilon)**2 + 1)
+            - 'inverse': 1.0/sqrt((r/epsilon)**2 + 1)
+            - 'gaussian': exp(-(r/epsilon)**2)
+            - 'linear': r
+            - 'cubic': r**3
+            - 'quintic': r**5
+            - 'thin_plate': r**2 * log(r)
+        epsilon : float, optional
+            形状参数，影响函数的"尖锐度"
+        smooth : float, default=0.0
+            平滑参数，用于处理噪声数据
+        """
+        self.function = function
+        self.epsilon = epsilon
+        self.smooth = smooth
+        self.rbf = None
+
+    def fit(self, xyzv: np.ndarray):
+        """
+        训练RBF模型
+
+        Parameters:
+        -----------
+        xyzv : np.ndarray, shape (N, 3)
+            已知点数据，每行为 [x, y, z] (对于2D插值，z为插值目标值)
+
+        Returns:
+        --------
+        self : RBF2D
+            返回自身以支持链式调用
+        """
+        xyzv = np.atleast_2d(xyzv)
+        if xyzv.shape[1] != 3:
+            raise ValueError("输入数据必须是3列：[x, y, z]")
+
+        self.rbf = Rbf(
+            xyzv[:, 0],
+            xyzv[:, 1],
+            xyzv[:, 2],
+            function=self.function,
+            epsilon=self.epsilon,
+            smooth=self.smooth,
+        )
+        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,)
+        """
+        if self.rbf is None:
+            raise ValueError("模型尚未训练，请先调用 fit() 方法")
+
+        # 检查输入是单点还是多点
+        is_single_point = xy.ndim == 1 or (xy.ndim == 2 and xy.shape[0] == 1)
+
+        xy = np.atleast_2d(xy)
+        if xy.shape[1] != 2:
+            raise ValueError("预测点坐标必须是2列：[x, y]")
+
+        z = self.rbf(xy[:, 0], xy[:, 1])
+
+        # 根据输入类型返回相应格式
+        if is_single_point:
+            return float(z[0])  # 单点返回标量
+        else:
+            return z  # 多点返回数组
+
+
+class RBF3D:
+    """
+    三维径向基函数插值
+
+    支持三维空间中的复杂属性插值
+    """
+
+    def __init__(self, function="multiquadric", epsilon=None, smooth=0.0):
+        """
+        初始化RBF3D插值器
+
+        Parameters:
+        -----------
+        function : str, default='multiquadric'
+            径向基函数类型
+        epsilon : float, optional
+            形状参数
+        smooth : float, default=0.0
+            平滑参数
+        """
+        self.function = function
+        self.epsilon = epsilon
+        self.smooth = smooth
+        self.rbf = None
+
+    def fit(self, xyzv: np.ndarray):
+        """
+        训练RBF3D模型
+
+        Parameters:
+        -----------
+        xyzv : np.ndarray, shape (N, 4)
+            已知点数据，每行为 [x, y, z, value]
+
+        Returns:
+        --------
+        self : RBF3D
+            返回自身以支持链式调用
+        """
+        xyzv = np.atleast_2d(xyzv)
+        if xyzv.shape[1] != 4:
+            raise ValueError("输入数据必须是4列：[x, y, z, value]")
+
+        self.rbf = Rbf(
+            xyzv[:, 0],
+            xyzv[:, 1],
+            xyzv[:, 2],
+            xyzv[:, 3],
+            function=self.function,
+            epsilon=self.epsilon,
+            smooth=self.smooth,
+        )
+        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,)
+        """
+        if self.rbf 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)
+        if xyz.shape[1] != 3:
+            raise ValueError("预测点坐标必须是3列：[x, y, z]")
+
+        v = self.rbf(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.rbf 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])
+
+        grid_x, grid_y, grid_z = np.meshgrid(x, y, z, indexing="ij")
+
+        # 直接使用网格进行预测
+        predictions = self.rbf(grid_x, grid_y, grid_z)
+
+        return grid_x, grid_y, grid_z, predictions
+
+
+class CustomRBF:
+    """
+    自定义径向基函数插值器
+
+    允许用户定义自己的径向基函数
+    """
+
+    def __init__(self, rbf_function, epsilon=1.0):
+        """
+        初始化自定义RBF插值器
+
+        Parameters:
+        -----------
+        rbf_function : callable
+            径向基函数，接受距离r作为参数
+        epsilon : float, default=1.0
+            形状参数
+        """
+        self.rbf_function = rbf_function
+        self.epsilon = epsilon
+        self.points = None
+        self.values = None
+        self.weights = None
+
+    def fit(self, xyzv: np.ndarray):
+        """
+        训练自定义RBF模型
+
+        Parameters:
+        -----------
+        xyzv : np.ndarray, shape (N, D+1)
+            已知点数据，前D列为坐标，最后一列为值
+
+        Returns:
+        --------
+        self : CustomRBF
+            返回自身以支持链式调用
+        """
+        xyzv = np.atleast_2d(xyzv)
+        if xyzv.shape[1] < 2:
+            raise ValueError("输入数据至少需要2列：[坐标..., value]")
+
+        self.points = xyzv[:, :-1]  # 前面的列为坐标
+        self.values = xyzv[:, -1]  # 最后一列为值
+
+        # 计算距离矩阵
+        distances = cdist(self.points, self.points)
+
+        # 构建RBF矩阵
+        rbf_matrix = self.rbf_function(distances / self.epsilon)
+
+        # 求解权重
+        self.weights = np.linalg.solve(rbf_matrix, self.values)
+
+        return self
+
+    def predict(self, query_points: np.ndarray) -> np.ndarray:
+        """
+        在指定位置进行插值预测
+
+        Parameters:
+        -----------
+        query_points : np.ndarray, shape (M, D)
+            查询点坐标
+
+        Returns:
+        --------
+        np.ndarray, shape (M,)
+            插值结果
+        """
+        if self.weights is None:
+            raise ValueError("模型尚未训练，请先调用 fit() 方法")
+
+        query_points = np.atleast_2d(query_points)
+
+        # 计算查询点到已知点的距离
+        distances = cdist(query_points, self.points)
+
+        # 计算RBF值
+        rbf_values = self.rbf_function(distances / self.epsilon)
+
+        # 加权求和
+        predictions = np.dot(rbf_values, self.weights)
+
+        return predictions.squeeze() if predictions.shape[0] == 1 else predictions
+
+
+# 预定义的径向基函数
+def gaussian_rbf(r):
+    """高斯径向基函数"""
+    return np.exp(-(r**2))
+
+
+def multiquadric_rbf(r):
+    """多二次径向基函数"""
+    return np.sqrt(1 + r**2)
+
+
+def inverse_multiquadric_rbf(r):
+    """逆多二次径向基函数"""
+    return 1.0 / np.sqrt(1 + r**2)
+
+
+def thin_plate_spline_rbf(r):
+    """薄板样条径向基函数"""
+    # 避免log(0)
+    r = np.maximum(r, 1e-10)
+    return r**2 * np.log(r)