oafuncs 0.0.98.22__tar.gz → 0.0.98.24__tar.gz

{oafuncs-0.0.98.22/oafuncs.egg-info → oafuncs-0.0.98.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oafuncs
-Version: 0.0.98.22
+Version: 0.0.98.24
 Summary: Oceanic and Atmospheric Functions
 Home-page: https://github.com/Industry-Pays/OAFuncs
 Author: Kun Liu

oafuncs-0.0.98.24/oafuncs/_script/data_interp_geo.py

@@ -0,0 +1,172 @@
+import importlib.util
+from typing import List, Union
+
+import numpy as np
+
+from oafuncs.oa_tool import PEx
+
+# 检查pyinterp是否可用
+pyinterp_available = importlib.util.find_spec("pyinterp") is not None
+
+if pyinterp_available:
+    import pyinterp
+    import pyinterp.backends.xarray as pyxr
+    import xarray as xr
+
+
+def _fill_nan_with_nearest(data: np.ndarray, source_lons: np.ndarray, source_lats: np.ndarray) -> np.ndarray:
+    """
+    使用最近邻方法填充NaN值，适合地理数据。
+    """
+    if not np.isnan(data).any():
+        return data
+
+    # 创建掩码，区分有效值和NaN值
+    mask = ~np.isnan(data)
+    if not np.any(mask):
+        return data  # 全是NaN，无法填充
+
+    # 使用pyinterp的RTree进行最近邻插值填充NaN
+    try:
+        if not pyinterp_available:
+            raise ImportError("pyinterp not available")
+
+        # 获取有效数据点的位置和值
+        valid_points = np.column_stack((source_lons[mask].ravel(), source_lats[mask].ravel()))
+        valid_values = data[mask].ravel()
+
+        # 创建RTree
+        tree = pyinterp.RTree()
+        tree.insert(valid_points.astype(np.float64), valid_values.astype(np.float64))
+
+        # 获取所有点的坐标
+        all_points = np.column_stack((source_lons.ravel(), source_lats.ravel()))
+
+        # 最近邻插值
+        filled_values = tree.query(all_points[:, 0], all_points[:, 1], k=1)
+
+        return filled_values.reshape(data.shape)
+
+    except Exception:
+        # 备选方案：使用scipy的最近邻
+        from scipy.interpolate import NearestNDInterpolator
+
+        points = np.column_stack((source_lons[mask].ravel(), source_lats[mask].ravel()))
+        values = data[mask].ravel()
+
+        if len(values) > 0:
+            interp = NearestNDInterpolator(points, values)
+            return interp(source_lons.ravel(), source_lats.ravel()).reshape(data.shape)
+        else:
+            return data  # 无有效值可用于填充
+
+
+def _interp_single_worker(*args):
+    """
+    单slice插值worker，只使用pyinterp的bicubic方法，失败直接报错。
+    参数: data_slice, source_lons, source_lats, target_lons, target_lats
+    """
+    if not pyinterp_available:
+        raise ImportError("pyinterp package is required for geographic interpolation")
+
+    data_slice, source_lons, source_lats, target_lons, target_lats = args
+
+    # 预处理：填充NaN值以确保数据完整
+    if np.isnan(data_slice).any():
+        data_filled = _fill_nan_with_nearest(data_slice, source_lons, source_lats)
+    else:
+        data_filled = data_slice
+
+    # 创建xarray DataArray
+    da = xr.DataArray(
+        data_filled,
+        coords={"latitude": source_lats, "longitude": source_lons},
+        dims=("latitude", "longitude"),
+    )
+
+    # 创建Grid2D对象
+    grid = pyxr.Grid2D(da)
+
+    # 使用bicubic方法插值
+    result = grid.bicubic(coords={"longitude": target_lons.ravel(), "latitude": target_lats.ravel()}, bounds_error=False, num_threads=1).reshape(target_lons.shape)
+
+    return result
+
+
+def interp_2d_func_geo(
+    target_x_coordinates: Union[np.ndarray, List[float]],
+    target_y_coordinates: Union[np.ndarray, List[float]],
+    source_x_coordinates: Union[np.ndarray, List[float]],
+    source_y_coordinates: Union[np.ndarray, List[float]],
+    source_data: np.ndarray,
+) -> np.ndarray:
+    """
+    使用pyinterp进行地理插值，只使用bicubic方法。
+
+    Args:
+        target_x_coordinates: 目标点经度 (-180 to 180 或 0 to 360)
+        target_y_coordinates: 目标点纬度 (-90 to 90)
+        source_x_coordinates: 源数据经度 (-180 to 180 或 0 to 360)
+        source_y_coordinates: 源数据纬度 (-90 to 90)
+        source_data: 多维数组，最后两个维度为空间维度
+
+    Returns:
+        np.ndarray: 插值后的数据数组
+    """
+    if not pyinterp_available:
+        raise ImportError("pyinterp package is required for geographic interpolation")
+
+    # 验证纬度范围
+    if np.nanmin(target_y_coordinates) < -90 or np.nanmax(target_y_coordinates) > 90:
+        raise ValueError("Target latitude must be in range [-90, 90].")
+    if np.nanmin(source_y_coordinates) < -90 or np.nanmax(source_y_coordinates) > 90:
+        raise ValueError("Source latitude must be in range [-90, 90].")
+
+    # 确保使用numpy数组
+    source_x_coordinates = np.array(source_x_coordinates)
+    source_y_coordinates = np.array(source_y_coordinates)
+    target_x_coordinates = np.array(target_x_coordinates)
+    target_y_coordinates = np.array(target_y_coordinates)
+
+    # 创建网格坐标（如果是一维的）
+    if source_x_coordinates.ndim == 1:
+        source_x_coordinates, source_y_coordinates = np.meshgrid(source_x_coordinates, source_y_coordinates)
+    if target_x_coordinates.ndim == 1:
+        target_x_coordinates, target_y_coordinates = np.meshgrid(target_x_coordinates, target_y_coordinates)
+
+    # 验证源数据形状
+    if source_x_coordinates.shape != source_data.shape[-2:] or source_y_coordinates.shape != source_data.shape[-2:]:
+        raise ValueError("Shape of source_data does not match shape of source_x_coordinates or source_y_coordinates.")
+
+    # 处理多维数据
+    data_dims = source_data.ndim
+    if data_dims < 2:
+        raise ValueError(f"Source data must have at least 2 dimensions, but got {data_dims}.")
+    elif data_dims > 4:
+        raise ValueError(f"Source data has {data_dims} dimensions, but this function currently supports up to 4.")
+
+    # 扩展到4D
+    num_dims_to_add = 4 - data_dims
+    source_data = source_data.reshape((1,) * num_dims_to_add + source_data.shape)
+    t, z, y, x = source_data.shape
+
+    # 准备并行处理参数
+    params = []
+    for t_index in range(t):
+        for z_index in range(z):
+            params.append(
+                (
+                    source_data[t_index, z_index],
+                    source_x_coordinates[0, :],  # 假设经度在每行都相同
+                    source_y_coordinates[:, 0],  # 假设纬度在每列都相同
+                    target_x_coordinates,
+                    target_y_coordinates,
+                )
+            )
+
+    # 并行执行插值
+    with PEx() as executor:
+        results = executor.run(_interp_single_worker, params)
+
+    # 还原到原始维度
+    return np.squeeze(np.array(results).reshape((t, z) + target_x_coordinates.shape))

{oafuncs-0.0.98.22 → oafuncs-0.0.98.24}/oafuncs/_script/plot_dataset.py

@@ -263,10 +263,45 @@ def process_variable(var: str, data: xr.DataArray, dims: int, dims_name: Tuple[s
                             print(f"Error processing {var}_{dims_name[0]}-{i}_{dims_name[1]}-{j}: {e}")
 
 
-def func_plot_dataset(ds_in: Union[xr.Dataset, xr.DataArray], output_dir: str, xyzt_dims: Tuple[str, str, str, str] = ("longitude", "latitude", "level", "time"), plot_type: str = "contourf", fixed_colorscale: bool = False) -> None:
+def get_xyzt_names(ds_in, xyzt_dims):
+    dims_dict = {
+        "x": ["longitude", "lon", "x", "lon_rho", "lon_u", "lon_v", "xi_rho", "xi_u", "xi_v", 
+              "xc", "x_rho", "xlon", "nlon", "east_west", "i", "xh", "xq", "nav_lon"],
+        "y": ["latitude", "lat", "y", "lat_rho", "lat_u", "lat_v", "eta_rho", "eta_u", "eta_v", 
+              "yc", "y_rho", "ylat", "nlat", "north_south", "j", "yh", "yq", "nav_lat"],
+        "z": ["level", "lev", "z", "depth", "height", "pressure", "s_rho", "s_w", 
+              "altitude", "plev", "isobaric", "vertical", "k", "sigma", "hybrid", "theta", 
+              "pres", "sigma_level", "z_rho", "z_w", "layers", "deptht", "nav_lev"],
+        "t": ["time", "t", "ocean_time", "bry_time", 'frc_time', 
+              "time_counter", "Time", "Julian_day", "forecast_time", "clim_time", "model_time"],
+    }
+    if xyzt_dims is not None:
+        x_dim, y_dim, z_dim, t_dim = xyzt_dims
+        return x_dim, y_dim, z_dim, t_dim
+    data_dim_names = ds_in.dims
+    x_dim, y_dim, z_dim, t_dim = None, None, None, None
+    for dim in dims_dict['x']:
+        if dim in data_dim_names:
+            x_dim = dim
+            break
+    for dim in dims_dict['y']:
+        if dim in data_dim_names:
+            y_dim = dim
+            break
+    for dim in dims_dict['z']:
+        if dim in data_dim_names:
+            z_dim = dim
+            break
+    for dim in dims_dict['t']:
+        if dim in data_dim_names:
+            t_dim = dim
+            break
+    return x_dim, y_dim, z_dim, t_dim
+
+
+def func_plot_dataset(ds_in: Union[xr.Dataset, xr.DataArray], output_dir: str, xyzt_dims: Tuple[str, str, str, str] = None, plot_type: str = "contourf", fixed_colorscale: bool = False) -> None:
     """Plot variables from a NetCDF file and save the plots to the specified directory."""
     os.makedirs(output_dir, exist_ok=True)
-    x_dim, y_dim, z_dim, t_dim = xyzt_dims
 
     # Main processing function
     try:
@@ -277,9 +312,11 @@ def func_plot_dataset(ds_in: Union[xr.Dataset, xr.DataArray], output_dir: str, x
             var = ds_in.name if ds_in.name is not None else "unnamed_variable"
             print("=" * 120)
             print(f"Processing: {var}")
+            
             try:
                 dims = len(ds_in.shape)
                 dims_name = ds_in.dims
+                x_dim, y_dim, z_dim, t_dim = get_xyzt_names(ds_in, xyzt_dims)
                 process_variable(var, ds_in, dims, dims_name, output_dir, x_dim, y_dim, z_dim, t_dim, fixed_colorscale, plot_type)
             except Exception as e:
                 print(f"Error processing variable {var}: {e}")
@@ -295,6 +332,7 @@ def func_plot_dataset(ds_in: Union[xr.Dataset, xr.DataArray], output_dir: str, x
                 data = ds[var]
                 dims = len(data.shape)
                 dims_name = data.dims
+                x_dim, y_dim, z_dim, t_dim = get_xyzt_names(data, xyzt_dims)
                 try:
                     process_variable(var, data, dims, dims_name, output_dir, x_dim, y_dim, z_dim, t_dim, fixed_colorscale, plot_type)
                 except Exception as e:

{oafuncs-0.0.98.22 → oafuncs-0.0.98.24}/oafuncs/oa_data.py

@@ -13,7 +13,6 @@ SystemInfo: Windows 11
 Python Version: 3.11
 """
 
-
 from typing import Any, List, Union
 
 import numpy as np
@@ -22,7 +21,6 @@ import xarray as xr
 from rich import print
 from scipy.interpolate import interp1d
 
-
 __all__ = ["interp_along_dim", "interp_2d", "interp_2d_geo", "ensure_list", "mask_shapefile"]
 
 
@@ -152,7 +150,7 @@ def interp_2d(
         >>> print(result.shape)  # Expected output: (3, 3)
     """
     from ._script.data_interp import interp_2d_func
-    
+
     return interp_2d_func(
         target_x_coordinates=target_x_coordinates,
         target_y_coordinates=target_y_coordinates,
@@ -162,47 +160,73 @@ def interp_2d(
         interpolation_method=interpolation_method,
     )
 
-def interp_2d_geo(target_x_coordinates: Union[np.ndarray, List[float]], target_y_coordinates: Union[np.ndarray, List[float]], source_x_coordinates: Union[np.ndarray, List[float]], source_y_coordinates: Union[np.ndarray, List[float]], source_data: np.ndarray, interpolation_method: str = "cubic") -> np.ndarray:
+
+def interp_2d_geo(
+    target_x_coordinates: Union[np.ndarray, List[float]],
+    target_y_coordinates: Union[np.ndarray, List[float]],
+    source_x_coordinates: Union[np.ndarray, List[float]],
+    source_y_coordinates: Union[np.ndarray, List[float]],
+    source_data: np.ndarray,
+) -> np.ndarray:
     """
-    Perform 2D interpolation on the last two dimensions of a multi-dimensional array (spherical coordinates).
-    使用球面坐标系进行插值，适用于全球尺度的地理数据，能正确处理经度跨越日期线的情况。
+    使用pyinterp进行地理插值，适用于全球尺度的地理数据与区域数据。
+
+    特点:
+    - 正确处理经度跨越日期线的情况
+    - 自动选择最佳插值策略
+    - 处理规则网格和非规则数据
+    - 支持多维数据并行处理
 
     Args:
-        target_x_coordinates (Union[np.ndarray, List[float]]): Target grid's longitude (-180 to 180 or 0 to 360).
-        target_y_coordinates (Union[np.ndarray, List[float]]): Target grid's latitude (-90 to 90).
-        source_x_coordinates (Union[np.ndarray, List[float]]): Original grid's longitude (-180 to 180 or 0 to 360).
-        source_y_coordinates (Union[np.ndarray, List[float]]): Original grid's latitude (-90 to 90).
-        source_data (np.ndarray): Multi-dimensional array with the last two dimensions as spatial.
-        interpolation_method (str, optional): Interpolation method. Defaults to "cubic".
-            >>> optional: 'linear', 'nearest', 'cubic', 'quintic', etc.
+        target_x_coordinates: 目标点经度 (-180 to 180 或 0 to 360)
+        target_y_coordinates: 目标点纬度 (-90 to 90)
+        source_x_coordinates: 源数据经度 (-180 to 180 或 0 to 360)
+        source_y_coordinates: 源数据纬度 (-90 to 90)
+        source_data: 多维数组，最后两个维度为空间维度
+        interpolation_method: 插值方法: 只会使用 'bicubic' 方法。
 
     Returns:
-        np.ndarray: Interpolated data array.
-
-    Raises:
-        ValueError: If input shapes are invalid.
+        np.ndarray: 插值后的数据数组
 
     Examples:
-        >>> # 创建一个全球网格示例
-        >>> target_lon = np.arange(-180, 181, 1)  # 1度分辨率目标网格
+        >>> # 全球数据插值示例
+        >>> target_lon = np.arange(-180, 181, 1)
         >>> target_lat = np.arange(-90, 91, 1)
-        >>> source_lon = np.arange(-180, 181, 5)  # 5度分辨率源网格
+        >>> source_lon = np.arange(-180, 181, 5)
         >>> source_lat = np.arange(-90, 91, 5)
-        >>> # 创建一个简单的数据场 (例如温度场)
         >>> source_data = np.cos(np.deg2rad(source_lat.reshape(-1, 1))) * np.cos(np.deg2rad(source_lon))
-        >>> # 插值到高分辨率网格
         >>> result = interp_2d_geo(target_lon, target_lat, source_lon, source_lat, source_data)
-        >>> print(result.shape)  # Expected output: (181, 361)
     """
-    from ._script.data_interp_geo import interp_2d_func_geo
-    interp_2d_func_geo(
-        target_x_coordinates=target_x_coordinates,
-        target_y_coordinates=target_y_coordinates,
-        source_x_coordinates=source_x_coordinates,
-        source_y_coordinates=source_y_coordinates,
-        source_data=source_data,
-        interpolation_method=interpolation_method,
-    )
+    # 使用importlib检查pyinterp是否可用，避免直接import导致的警告
+    import importlib.util
+
+    pyinterp_available = importlib.util.find_spec("pyinterp") is not None
+
+    if pyinterp_available:
+        # 只在pyinterp可用时才导入相关模块
+        from ._script.data_interp_geo import interp_2d_func_geo
+
+        return interp_2d_func_geo(
+            target_x_coordinates=target_x_coordinates,
+            target_y_coordinates=target_y_coordinates,
+            source_x_coordinates=source_x_coordinates,
+            source_y_coordinates=source_y_coordinates,
+            source_data=source_data,
+        )
+    else:
+        print("[yellow]警告: pyinterp模块未安装，无法使用球面坐标插值。尝试使用平面插值作为备选方案。[/yellow]")
+        print("[yellow]推荐使用 pip install pyinterp 安装pyinterp以获得更准确的地理数据插值结果。[/yellow]")
+        try:
+            return interp_2d(
+                target_x_coordinates=target_x_coordinates,
+                target_y_coordinates=target_y_coordinates,
+                source_x_coordinates=source_x_coordinates,
+                source_y_coordinates=source_y_coordinates,
+                source_data=source_data,
+            )
+        except Exception as e:
+            raise ImportError(f"pyinterp不可用且备选插值方法也失败: {e}")
+
 
 def mask_shapefile(
     data_array: np.ndarray,

{oafuncs-0.0.98.22 → oafuncs-0.0.98.24}/oafuncs/oa_nc.py

@@ -246,7 +246,7 @@ def draw(
     output_directory: Optional[str] = None,
     dataset: Optional[xr.Dataset] = None,
     file_path: Optional[str] = None,
-    dimensions: Union[List[str], Tuple[str, str, str, str]] = ("longitude", "latitude", "level", "time"),
+    dims_xyzt: Union[List[str], Tuple[str, str, str, str]] = None,
     plot_style: str = "contourf",
     use_fixed_colorscale: bool = False,
 ) -> None:
@@ -257,7 +257,7 @@ def draw(
         output_directory (Optional[str]): Path of the output directory.
         dataset (Optional[xr.Dataset]): Xarray dataset to plot.
         file_path (Optional[str]): Path to the NetCDF file.
-        dimensions (Union[List[str], Tuple[str, str, str, str]]): Dimensions for plotting.
+        dims_xyzt (Union[List[str], Tuple[str, str, str, str]]): Dimensions for plotting. xyzt
         plot_style (str): Type of the plot, e.g., "contourf" or "contour". Default is "contourf".
         use_fixed_colorscale (bool): Whether to use a fixed colorscale. Default is False.
 
@@ -268,15 +268,15 @@ def draw(
 
     if output_directory is None:
         output_directory = os.getcwd()
-    if not isinstance(dimensions, (list, tuple)):
+    if not isinstance(dims_xyzt, (list, tuple)):
         raise ValueError("dimensions must be a list or tuple")
 
     if dataset is not None:
-        func_plot_dataset(dataset, output_directory, tuple(dimensions), plot_style, use_fixed_colorscale)
+        func_plot_dataset(dataset, output_directory, tuple(dims_xyzt), plot_style, use_fixed_colorscale)
     elif file_path is not None:
         if check(file_path):
             ds = xr.open_dataset(file_path)
-            func_plot_dataset(ds, output_directory, tuple(dimensions), plot_style, use_fixed_colorscale)
+            func_plot_dataset(ds, output_directory, tuple(dims_xyzt), plot_style, use_fixed_colorscale)
         else:
             print(f"[red]Invalid file: {file_path}[/red]")
     else:
@@ -288,10 +288,11 @@ def compress(src_path, dst_path=None,convert_dtype='int16'):
     压缩 NetCDF 文件，使用 scale_factor/add_offset 压缩数据。
     若 dst_path 省略，则自动生成新文件名，写出后删除原文件并将新文件改回原名。
     """
+    src_path = str(src_path)
     # 判断是否要替换原文件
     delete_orig = dst_path is None
     if delete_orig:
-        dst_path = src_path.replace(".nc", "_compress.nc")
+        dst_path = src_path.replace(".nc", "_compress_temp.nc")
 
     ds = xr.open_dataset(src_path)
     save(dst_path, ds, convert_dtype=convert_dtype, use_scale_offset=True, use_compression=True)
@@ -313,10 +314,11 @@ def unscale(src_path, dst_path=None, compression_level=4):
         dst_path: 目标文件路径，None则替换原文件
         compression_level: 压缩级别(1-9)，数值越大压缩比越高，速度越慢
     """
+    src_path = str(src_path)
     # 判断是否要替换原文件
     delete_orig = dst_path is None
     if delete_orig:
-        dst_path = src_path.replace(".nc", "_unpacked.nc")
+        dst_path = src_path.replace(".nc", "_unpacked_temp.nc")
 
     # 打开原始文件，获取文件大小
     orig_size = os.path.getsize(src_path) / (1024 * 1024)  # MB

{oafuncs-0.0.98.22 → oafuncs-0.0.98.24}/oafuncs/oa_tool.py

@@ -135,7 +135,7 @@ def email(title: str = "Title", content: Optional[str] = None, send_to: str = "1
 
 def pbar(
     iterable: Iterable = range(100),
-    description: str = "Working",
+    description: str = None,
     total: Optional[float] = None,
     completed: float = 0,
     color: Any = "None",
@@ -162,21 +162,9 @@ def pbar(
 
     Returns:
         Any: An instance of ColorProgressBar.
-
-    Example:
-        >>> for i in pbar(range(10), description="Processing"):
-        ...     time.sleep(0.1)
-        >>> for i in pbar(range(10), description="Processing", color="green"):
-        ...     time.sleep(0.1)
-        >>> for i in pbar(range(10), description="Processing", cmap=["red", "green"]):
-        ...     time.sleep(0.1)
-        >>> for i in pbar(range(10), description="Processing", cmap="viridis"):
-        ...     time.sleep(0.1)
     """
     from ._script.cprogressbar import ColorProgressBar
     import random
-    
-    # number = random.randint(1, 999)
 
     def _generate_random_color_hex():
         """Generate a random color in hexadecimal format."""
@@ -188,11 +176,10 @@ def pbar(
     if color == 'None' and cmap is None:
         color = _generate_random_color_hex()
 
-    style = f"bold {color if color != 'None' else 'green'}"
-    # print(f"[{style}]~*^* {description} *^*~ -> {number:03d}[/{style}]")
-    print(f"[{style}]~*^* {description} *^*~[/{style}]")
+    if description is not None:
+        style = f"bold {color if color != 'None' else 'green'}"
+        print(f"[{style}]~*^* {description} *^*~[/{style}]")
 
-    # description=f'{number:03d}'
     description = ""
     
     return ColorProgressBar(

{oafuncs-0.0.98.22 → oafuncs-0.0.98.24/oafuncs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oafuncs
-Version: 0.0.98.22
+Version: 0.0.98.24
 Summary: Oceanic and Atmospheric Functions
 Home-page: https://github.com/Industry-Pays/OAFuncs
 Author: Kun Liu

{oafuncs-0.0.98.22 → oafuncs-0.0.98.24}/setup.py

@@ -18,7 +18,7 @@ URL = "https://github.com/Industry-Pays/OAFuncs"
 EMAIL = "liukun0312@stu.ouc.edu.cn"
 AUTHOR = "Kun Liu"
 REQUIRES_PYTHON = ">=3.9.0"  # 2025/03/13
-VERSION = "0.0.98.22"
+VERSION = "0.0.98.24"
 
 # What packages are required for this module to be executed?
 REQUIRED = [

oafuncs-0.0.98.22/oafuncs/_script/data_interp_geo.py

@@ -1,167 +0,0 @@
-from typing import List, Union
-
-import numpy as np
-from scipy.interpolate import NearestNDInterpolator, griddata
-
-from oafuncs.oa_tool import PEx
-
-
-def _normalize_lon(lon, ref_lon):
-    """
-    将经度数组 lon 归一化到与 ref_lon 相同的区间（[-180,180] 或 [0,360]）
-    并在经度分界（如180/-180, 0/360）附近自动拓宽，避免插值断裂。
-    """
-    lon = np.asarray(lon)
-    ref_lon = np.asarray(ref_lon)
-    if np.nanmax(ref_lon) > 180:
-        lon = np.where(lon < 0, lon + 360, lon)
-    else:
-        lon = np.where(lon > 180, lon - 360, lon)
-    return lon
-
-
-def _expand_lonlat_for_dateline(points, values):
-    """
-    对经度分界（如180/-180, 0/360）附近的数据进行拓宽，避免插值断裂。
-    points: (N,2) [lon,lat]
-    values: (N,)
-    返回拓宽后的 points, values
-    """
-    lon = points[:, 0]
-    lat = points[:, 1]
-    expanded_points = [points]
-    expanded_values = [values]
-    if (np.nanmax(lon) > 170) and (np.nanmin(lon) < -170):
-        expanded_points.append(np.column_stack((lon + 360, lat)))
-        expanded_points.append(np.column_stack((lon - 360, lat)))
-        expanded_values.append(values)
-        expanded_values.append(values)
-    if (np.nanmax(lon) > 350) and (np.nanmin(lon) < 10):
-        expanded_points.append(np.column_stack((lon - 360, lat)))
-        expanded_points.append(np.column_stack((lon + 360, lat)))
-        expanded_values.append(values)
-        expanded_values.append(values)
-    points_new = np.vstack(expanded_points)
-    values_new = np.concatenate(expanded_values)
-    return points_new, values_new
-
-
-def _interp_single_worker(*args):
-    """
-    用于PEx并行的单slice插值worker。
-    参数: data_slice, origin_points, target_points, interpolation_method, target_shape
-    球面插值：经纬度转球面坐标后插值
-    """
-    data_slice, origin_points, target_points, interpolation_method, target_shape = args
-
-    # 经纬度归一化
-    origin_points = origin_points.copy()
-    target_points = target_points.copy()
-    origin_points[:, 0] = _normalize_lon(origin_points[:, 0], target_points[:, 0])
-    target_points[:, 0] = _normalize_lon(target_points[:, 0], origin_points[:, 0])
-
-    def lonlat2xyz(lon, lat):
-        lon_rad = np.deg2rad(lon)
-        lat_rad = np.deg2rad(lat)
-        x = np.cos(lat_rad) * np.cos(lon_rad)
-        y = np.cos(lat_rad) * np.sin(lon_rad)
-        z = np.sin(lat_rad)
-        return np.stack([x, y, z], axis=-1)
-
-    # 过滤掉包含 NaN 的点
-    valid_mask = ~np.isnan(data_slice.ravel())
-    valid_data = data_slice.ravel()[valid_mask]
-    valid_points = origin_points[valid_mask]
-
-    if len(valid_data) < 10:
-        return np.full(target_shape, np.nanmean(data_slice))
-
-    # 拓宽经度分界，避免如179/-181插值断裂
-    valid_points_exp, valid_data_exp = _expand_lonlat_for_dateline(valid_points, valid_data)
-
-    valid_xyz = lonlat2xyz(valid_points_exp[:, 0], valid_points_exp[:, 1])
-    target_xyz = lonlat2xyz(target_points[:, 0], target_points[:, 1])
-
-    # 使用 griddata 的 cubic 插值以获得更好平滑效果
-    result = griddata(valid_xyz, valid_data_exp, target_xyz, method=interpolation_method).reshape(target_shape)
-
-    # 用最近邻处理残余 NaN
-    if np.isnan(result).any():
-        nn_interp = NearestNDInterpolator(valid_xyz, valid_data_exp)
-        nn = nn_interp(target_xyz).reshape(target_shape)
-        result[np.isnan(result)] = nn[np.isnan(result)]
-
-    return result
-
-
-def interp_2d_func_geo(target_x_coordinates: Union[np.ndarray, List[float]], target_y_coordinates: Union[np.ndarray, List[float]], source_x_coordinates: Union[np.ndarray, List[float]], source_y_coordinates: Union[np.ndarray, List[float]], source_data: np.ndarray, interpolation_method: str = "cubic") -> np.ndarray:
-    """
-    Perform 2D interpolation on the last two dimensions of a multi-dimensional array (spherical coordinates).
-    使用球面坐标系进行插值，适用于全球尺度的地理数据，能正确处理经度跨越日期线的情况。
-
-    Args:
-        target_x_coordinates (Union[np.ndarray, List[float]]): Target grid's longitude (-180 to 180 or 0 to 360).
-        target_y_coordinates (Union[np.ndarray, List[float]]): Target grid's latitude (-90 to 90).
-        source_x_coordinates (Union[np.ndarray, List[float]]): Original grid's longitude (-180 to 180 or 0 to 360).
-        source_y_coordinates (Union[np.ndarray, List[float]]): Original grid's latitude (-90 to 90).
-        source_data (np.ndarray): Multi-dimensional array with the last two dimensions as spatial.
-        interpolation_method (str, optional): Interpolation method. Defaults to "cubic".
-            >>> optional: 'linear', 'nearest', 'cubic', 'quintic', etc.
-
-    Returns:
-        np.ndarray: Interpolated data array.
-
-    Raises:
-        ValueError: If input shapes are invalid.
-
-    Examples:
-        >>> # 创建一个全球网格示例
-        >>> target_lon = np.arange(-180, 181, 1)  # 1度分辨率目标网格
-        >>> target_lat = np.arange(-90, 91, 1)
-        >>> source_lon = np.arange(-180, 181, 5)  # 5度分辨率源网格
-        >>> source_lat = np.arange(-90, 91, 5)
-        >>> # 创建一个简单的数据场 (例如温度场)
-        >>> source_data = np.cos(np.deg2rad(source_lat.reshape(-1, 1))) * np.cos(np.deg2rad(source_lon))
-        >>> # 插值到高分辨率网格
-        >>> result = interp_2d_geo(target_lon, target_lat, source_lon, source_lat, source_data)
-        >>> print(result.shape)  # Expected output: (181, 361)
-    """
-    # 验证输入数据范围
-    if np.nanmin(target_y_coordinates) < -90 or np.nanmax(target_y_coordinates) > 90:
-        raise ValueError("[red]Target latitude must be in range [-90, 90].[/red]")
-    if np.nanmin(source_y_coordinates) < -90 or np.nanmax(source_y_coordinates) > 90:
-        raise ValueError("[red]Source latitude must be in range [-90, 90].[/red]")
-
-    if len(target_y_coordinates.shape) == 1:
-        target_x_coordinates, target_y_coordinates = np.meshgrid(target_x_coordinates, target_y_coordinates)
-    if len(source_y_coordinates.shape) == 1:
-        source_x_coordinates, source_y_coordinates = np.meshgrid(source_x_coordinates, source_y_coordinates)
-
-    if source_x_coordinates.shape != source_data.shape[-2:] or source_y_coordinates.shape != source_data.shape[-2:]:
-        raise ValueError("[red]Shape of source_data does not match shape of source_x_coordinates or source_y_coordinates.[/red]")
-
-    target_points = np.column_stack((np.array(target_x_coordinates).ravel(), np.array(target_y_coordinates).ravel()))
-    origin_points = np.column_stack((np.array(source_x_coordinates).ravel(), np.array(source_y_coordinates).ravel()))
-
-    data_dims = len(source_data.shape)
-    if data_dims < 2:
-        raise ValueError(f"[red]Source data must have at least 2 dimensions, but got {data_dims}.[/red]")
-    elif data_dims > 4:
-        raise ValueError(f"Source data has {data_dims} dimensions, but this function currently supports only up to 4.")
-
-    num_dims_to_add = 4 - data_dims
-    new_shape = (1,) * num_dims_to_add + source_data.shape
-    new_src_data = source_data.reshape(new_shape)
-
-    t, z, y, x = new_src_data.shape
-
-    params = []
-    target_shape = target_y_coordinates.shape
-    for t_index in range(t):
-        for z_index in range(z):
-            params.append((new_src_data[t_index, z_index], origin_points, target_points, interpolation_method, target_shape))
-
-    with PEx() as excutor:
-        result = excutor.run(_interp_single_worker, params)
-
-    return np.squeeze(np.array(result).reshape(t, z, *target_shape))