oafuncs 0.0.98.22__py3-none-any.whl → 0.0.98.23__py3-none-any.whl

oafuncs/_script/data_interp_geo.py

@@ -1,148 +1,214 @@
 from typing import List, Union
 
 import numpy as np
-from scipy.interpolate import NearestNDInterpolator, griddata
+import importlib.util
 
 from oafuncs.oa_tool import PEx
 
+# 检查pyinterp是否可用
+pyinterp_available = importlib.util.find_spec("pyinterp") is not None
 
-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
+# 仅在pyinterp可用时导入相关模块
+if pyinterp_available:
+    import pyinterp
+    from pyinterp.interpolator import RegularGridInterpolator, RTree
 
 
 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, source_xy_shape
+    使用pyinterp进行地理插值
     """
-    data_slice, origin_points, target_points, interpolation_method, target_shape = args
+    # 确保pyinterp可用
+    if not pyinterp_available:
+        raise ImportError("pyinterp package is required for geographic interpolation")
+        
+    data_slice, origin_points, target_points, interpolation_method, target_shape, source_xy_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:
+    if np.count_nonzero(valid_mask) < 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)
+    # 准备有效数据点
+    valid_data = data_slice.ravel()[valid_mask]
+    valid_points = origin_points[valid_mask]
 
-    # 用最近邻处理残余 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)]
+    # 根据插值方法选择合适的策略
+    if origin_points.shape[0] == source_xy_shape[0] * source_xy_shape[1]:  # 规则网格
+        try:
+            # 尝试使用规则网格插值
+            y_size, x_size = source_xy_shape
+            lons = origin_points[:, 0].reshape(y_size, x_size)[0, :]
+            lats = origin_points[:, 1].reshape(y_size, x_size)[:, 0]
+
+            # 检查网格数据的有效性
+            grid_data = data_slice.reshape(source_xy_shape)
+            nan_ratio = np.isnan(grid_data).sum() / grid_data.size
+            if nan_ratio > 0.5:  # 如果超过50%是NaN，跳过规则网格插值
+                raise ValueError("Too many NaN values in grid data")
+
+            # 创建pyinterp网格 - 设置经度循环
+            is_global = np.abs((lons[-1] - lons[0]) % 360 - 360) < 1e-6
+            grid = pyinterp.Grid2D(
+                x=pyinterp.Axis(lons, is_circle=is_global),  # 根据数据判断是否为全球网格
+                y=pyinterp.Axis(lats),
+                array=grid_data,
+                increasing_axes=(-2, -1),  # 确保坐标轴方向正确
+            )
+
+            # 创建插值器并执行插值
+            method_map = {"bilinear": "bilinear", "linear": "bilinear", "cubic": "bicubic", "nearest": "nearest"}
+            interpolator = RegularGridInterpolator(grid, method=method_map.get(interpolation_method, "bilinear"))
+
+            # 执行插值 - 使用geodetic坐标系统确保正确处理地球曲率
+            coords = pyinterp.geodetic.Coordinates(target_points[:, 0], target_points[:, 1], pyinterp.geodetic.System.WGS84)
+
+            result = interpolator.interpolate(coords).reshape(target_shape)
+
+            # 如果规则网格插值没有产生太多NaN值，直接返回结果
+            if np.isnan(result).sum() / result.size < 0.05:
+                return result
+
+        except Exception:  # noqa
+            # 失败时使用RTree插值
+            pass
+
+    # 使用RTree进行非规则网格插值或填补规则网格产生的NaN
+    try:
+        # 创建RTree插值器
+        mesh = RTree(pyinterp.geodetic.Coordinates(valid_points[:, 0], valid_points[:, 1], pyinterp.geodetic.System.WGS84), valid_data)
+
+        # 根据插值方法和有效点数量选择合适的插值策略
+        coords = pyinterp.geodetic.Coordinates(target_points[:, 0], target_points[:, 1], pyinterp.geodetic.System.WGS84)
+
+        if interpolation_method in ["cubic", "quintic"] and len(valid_data) > 100:
+            # 对于点数充足的情况，高阶插值使用径向基函数
+            result = mesh.radial_basis_function(
+                coords,
+                function="thin_plate",  # 薄板样条，适合地理数据
+                epsilon=0.1,  # 平滑参数
+                norm="geodetic",  # 使用地理距离
+                within=False,  # 允许外推
+            ).reshape(target_shape)
+        else:
+            # 使用IDW，动态调整k值
+            k_value = max(min(int(np.sqrt(len(valid_data))), 16), 4)  # 自适应近邻点数
+            result, _ = mesh.inverse_distance_weighting(
+                coords,
+                k=k_value,
+                p=2.0,  # 平方反比权重
+                within=False,  # 允许外推
+            ).reshape(target_shape)
+
+        # 检查插值结果，如果有NaN，尝试使用最近邻补充
+        if np.isnan(result).any():
+            nan_mask = np.isnan(result)
+            nan_coords = pyinterp.geodetic.Coordinates(target_points[nan_mask.ravel(), 0], target_points[nan_mask.ravel(), 1], pyinterp.geodetic.System.WGS84)
+            nn_values, _ = mesh.k_nearest(nan_coords, k=1)
+            result[nan_mask] = nn_values
+
+    except Exception:
+        # 如果所有复杂插值方法都失败，使用最基本的最近邻
+        try:
+            # 创建新的RTree对象尝试避免之前可能的问题
+            simple_mesh = RTree(pyinterp.geodetic.Coordinates(valid_points[:, 0], valid_points[:, 1], pyinterp.geodetic.System.WGS84), valid_data)
+
+            simple_coords = pyinterp.geodetic.Coordinates(target_points[:, 0], target_points[:, 1], pyinterp.geodetic.System.WGS84)
+
+            result, _ = simple_mesh.k_nearest(simple_coords, k=1).reshape(target_shape)
+        except Exception:
+            # 极端情况下，使用平均值填充
+            result = np.full(target_shape, np.nanmean(valid_data))
 
     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).
-    使用球面坐标系进行插值，适用于全球尺度的地理数据，能正确处理经度跨越日期线的情况。
+    使用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: 插值方法:
+            - 'nearest': 最近邻插值
+            - 'linear'/'bilinear': 双线性插值
+            - 'cubic': 三次样条插值
+            - 'quintic': 五次样条插值
 
     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)
+        >>> result = interp_2d_func_geo(target_lon, target_lat, source_lon, source_lat, source_data)
     """
+    # 确保pyinterp可用
+    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("[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()))
+    source_xy_shape = source_x_coordinates.shape
+
+    # 统一经度表示系统
+    origin_points = origin_points.copy()
+    target_points = target_points.copy()
 
+    # 检测经度系统并统一
+    src_lon_range = np.nanmax(origin_points[:, 0]) - np.nanmin(origin_points[:, 0])
+    tgt_lon_range = np.nanmax(target_points[:, 0]) - np.nanmin(target_points[:, 0])
+
+    # 如果数据接近全球范围并且表示系统不同，则统一表示系统
+    if (src_lon_range > 300 or tgt_lon_range > 300) and ((np.nanmax(target_points[:, 0]) > 180 and np.nanmin(origin_points[:, 0]) < 0) or (np.nanmax(origin_points[:, 0]) > 180 and np.nanmin(target_points[:, 0]) < 0)):
+        # 优先使用[0,360]系统，因为它不会在日期线处断开
+        if np.nanmax(target_points[:, 0]) > 180 or np.nanmax(origin_points[:, 0]) > 180:
+            # 转换为[0,360]系统
+            if np.nanmin(origin_points[:, 0]) < 0:
+                origin_points[:, 0] = np.where(origin_points[:, 0] < 0, origin_points[:, 0] + 360, origin_points[:, 0])
+            if np.nanmin(target_points[:, 0]) < 0:
+                target_points[:, 0] = np.where(target_points[:, 0] < 0, target_points[:, 0] + 360, target_points[:, 0])
+        else:
+            # 转换为[-180,180]系统
+            if np.nanmax(origin_points[:, 0]) > 180:
+                origin_points[:, 0] = np.where(origin_points[:, 0] > 180, origin_points[:, 0] - 360, origin_points[:, 0])
+            if np.nanmax(target_points[:, 0]) > 180:
+                target_points[:, 0] = np.where(target_points[:, 0] > 180, target_points[:, 0] - 360, target_points[:, 0])
+
+    # 处理多维数据
     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]")
@@ -155,12 +221,14 @@ def interp_2d_func_geo(target_x_coordinates: Union[np.ndarray, List[float]], tar
 
     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))
+            params.append((new_src_data[t_index, z_index], origin_points, target_points, interpolation_method, target_shape, source_xy_shape))
 
+    # 并行处理
     with PEx() as excutor:
         result = excutor.run(_interp_single_worker, params)
 

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/oa_data.py

@@ -164,45 +164,68 @@ def interp_2d(
 
 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:
     """
-    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: 插值方法:
+            - 'nearest': 最近邻插值
+            - 'linear'/'bilinear': 双线性插值
+            - 'cubic': 三次样条插值
+            - 'quintic': 五次样条插值
 
     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,
+            interpolation_method=interpolation_method,
+        )
+    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,
+                interpolation_method=interpolation_method,
+            )
+        except Exception as e:
+            raise ImportError(f"pyinterp不可用且备选插值方法也失败: {e}")
 
 def mask_shapefile(
     data_array: np.ndarray,

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/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.dist-info → oafuncs-0.0.98.23.dist-info}/METADATA

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

{oafuncs-0.0.98.22.dist-info → oafuncs-0.0.98.23.dist-info}/RECORD

@@ -1,25 +1,25 @@
 oafuncs/__init__.py,sha256=T_-VtnWWllV3Q91twT5Yt2sUapeA051QbPNnBxmg9nw,1456
 oafuncs/oa_cmap.py,sha256=pUFAGzbIg0WLxObBP2t_--ZIg00Dxdojx0y7OjTeqEo,11551
-oafuncs/oa_data.py,sha256=Aat9ktxxRGevaqQya3IJWfXeoEs-FCXGUcNE2pKnzfU,10931
+oafuncs/oa_data.py,sha256=klKi3wD-hrtr5tUTD_5sHy306KPbVV7yQYwzcVNKJbg,11684
 oafuncs/oa_date.py,sha256=WhM6cyD4G3IeghjLTHhAMtlvJbA7kwQG2sHnxdTgyso,6303
 oafuncs/oa_draw.py,sha256=IaBGDx-EOxyMM2IuJ4zLZt6ruHHV5qFStPItmUOXoWk,17635
 oafuncs/oa_file.py,sha256=j9gXJgPOJsliu4IOUc4bc-luW4yBvQyNCEmMyDVjUwQ,16404
 oafuncs/oa_help.py,sha256=_4AZgRDq5Or0vauNvq5IDDHIBoBfdOQtzak-mG1wwAw,4537
-oafuncs/oa_nc.py,sha256=UUXnBg2cO5XiJ8w0jNqCZJg83FVKqxlEHxOJG5o08Z8,15201
+oafuncs/oa_nc.py,sha256=pxTyR8f2mlu1Zkz4PJ5ImOyhrFD_mgytXHJjt9ohnUw,15233
 oafuncs/oa_python.py,sha256=NkopwkYFGSEuVljnTBvXCl6o2CeyRNBqRXSsUl3euEE,5192
-oafuncs/oa_tool.py,sha256=QBjJh3pf54yXVuOmu97rW6Tsr6uNMyZ5KqZbR4VQFTc,8628
+oafuncs/oa_tool.py,sha256=Zuaoa92wll0YqXGRf0oF_c7wlATtl7bvjCuLt9VLXp0,8046
 oafuncs/_data/hycom.png,sha256=MadKs6Gyj5n9-TOu7L4atQfTXtF9dvN9w-tdU9IfygI,10945710
 oafuncs/_data/oafuncs.png,sha256=o3VD7wm-kwDea5E98JqxXl04_78cBX7VcdUt7uQXGiU,3679898
 oafuncs/_script/cprogressbar.py,sha256=UIgGcLFs-6IgWlITuBLaQqrpt4OAK3Mst5RlCiNfZdQ,15772
 oafuncs/_script/data_interp.py,sha256=EiZbt6n5BEaRKcng88UgX7TFPhKE6TLVZniS01awXjg,5146
-oafuncs/_script/data_interp_geo.py,sha256=ZRFb3fKRiYQViZNHd19eW20C9i38BsiIU8w0fG5mbqM,7789
+oafuncs/_script/data_interp_geo.py,sha256=MFp4ADqVFr_g-5bj6104V8U4f5-rAiQm8cfP4XceMY0,11532
 oafuncs/_script/email.py,sha256=lL4HGKrr524-g0xLlgs-4u7x4-u7DtgNoD9AL8XJKj4,3058
 oafuncs/_script/netcdf_merge.py,sha256=tM9ePqLiEsE7eIsNM5XjEYeXwxjYOdNz5ejnEuI7xKw,6066
 oafuncs/_script/netcdf_modify.py,sha256=sGRUYNhfGgf9JV70rnBzw3bzuTRSXzBTL_RMDnDPeLQ,4552
 oafuncs/_script/netcdf_write.py,sha256=GvyUyUhzMonzSp3y4pT8ZAfbQrsh5J3dLnmINYJKhuE,21422
 oafuncs/_script/parallel.py,sha256=07-BJVHxXJNlrOrhrSGt7qCZiKWq6dBvNDBA1AANYnI,8861
 oafuncs/_script/parallel_test.py,sha256=0GBqZOX7IaCOKF2t1y8N8YYu53GJ33OkfsWgpvZNqM4,372
-oafuncs/_script/plot_dataset.py,sha256=zkSEnO_-biyagorwWXPoihts_cwuvripzEt-l9bHJ2E,13989
+oafuncs/_script/plot_dataset.py,sha256=Hr4X0BHJ1qmf2YHT40Vu3nF8JS_4MlZ2MK6yeJCSHOg,15642
 oafuncs/_script/replace_file_content.py,sha256=eCFZjnZcwyRvy6b4mmIfBna-kylSZTyJRfgXd6DdCjk,5982
 oafuncs/oa_down/User_Agent-list.txt,sha256=pHaMlElMvZ8TG4vf4BqkZYKqe0JIGkr4kCN0lM1Y9FQ,514295
 oafuncs/oa_down/__init__.py,sha256=kRX5eTUCbAiz3zTaQM1501paOYS_3fizDN4Pa0mtNUA,585
@@ -39,8 +39,8 @@ oafuncs/oa_sign/__init__.py,sha256=QKqTFrJDFK40C5uvk48GlRRbGFzO40rgkYwu6dYxatM,5
 oafuncs/oa_sign/meteorological.py,sha256=8091SHo2L8kl4dCFmmSH5NGVHDku5i5lSiLEG5DLnOQ,6489
 oafuncs/oa_sign/ocean.py,sha256=xrW-rWD7xBWsB5PuCyEwQ1Q_RDKq2KCLz-LOONHgldU,5932
 oafuncs/oa_sign/scientific.py,sha256=a4JxOBgm9vzNZKpJ_GQIQf7cokkraV5nh23HGbmTYKw,5064
-oafuncs-0.0.98.22.dist-info/licenses/LICENSE.txt,sha256=rMtLpVg8sKiSlwClfR9w_Dd_5WubTQgoOzE2PDFxzs4,1074
-oafuncs-0.0.98.22.dist-info/METADATA,sha256=ctJ9aAoY3RztAP6gD2STCFB0ZZaCbXQV8SufCLMGkbM,4273
-oafuncs-0.0.98.22.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-oafuncs-0.0.98.22.dist-info/top_level.txt,sha256=bgC35QkXbN4EmPHEveg_xGIZ5i9NNPYWqtJqaKqTPsQ,8
-oafuncs-0.0.98.22.dist-info/RECORD,,
+oafuncs-0.0.98.23.dist-info/licenses/LICENSE.txt,sha256=rMtLpVg8sKiSlwClfR9w_Dd_5WubTQgoOzE2PDFxzs4,1074
+oafuncs-0.0.98.23.dist-info/METADATA,sha256=uLPiMYNdGE_FAuzYqOVV2s3LM-gFmGUBvEyf6t4Fni8,4273
+oafuncs-0.0.98.23.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+oafuncs-0.0.98.23.dist-info/top_level.txt,sha256=bgC35QkXbN4EmPHEveg_xGIZ5i9NNPYWqtJqaKqTPsQ,8
+oafuncs-0.0.98.23.dist-info/RECORD,,

{oafuncs-0.0.98.22.dist-info → oafuncs-0.0.98.23.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any