oafuncs 0.0.96__tar.gz → 0.0.97.1__tar.gz

oafuncs-0.0.97.1/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE.txt
+include README.md
+recursive-include oafuncs/data_store *
+recursive-include oafuncs/oa_down *.txt

{oafuncs-0.0.96/oafuncs.egg-info → oafuncs-0.0.97.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: oafuncs
-Version: 0.0.96
+Version: 0.0.97.1
 Summary: Oceanic and Atmospheric Functions
 Home-page: https://github.com/Industry-Pays/OAFuncs
 Author: Kun Liu
@@ -9,7 +9,6 @@ License: MIT
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{oafuncs-0.0.96 → oafuncs-0.0.97.1}/oafuncs/__init__.py

@@ -4,8 +4,8 @@
 Author: Liu Kun && 16031215@qq.com
 Date: 2024-09-17 16:09:20
 LastEditors: Liu Kun && 16031215@qq.com
-LastEditTime: 2024-12-13 12:31:06
-FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_s\\__init__.py
+LastEditTime: 2025-03-09 16:28:01
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\__init__.py
 Description:
 EditPlatform: vscode
 ComputerInfo: XPS 15 9510
@@ -27,18 +27,28 @@ Python Version: 3.12
 # path: My_Funcs/OAFuncs/oafuncs/
 from .oa_cmap import *
 from .oa_data import *
+
+# ------------------- 2024-12-13 12:31:06 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/oa_down/
+from .oa_down import *
 from .oa_draw import *
 from .oa_file import *
 from .oa_help import *
+
+# ------------------- 2024-12-13 12:31:06 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/oa_model/
+from .oa_model import *
 from .oa_nc import *
 from .oa_python import *
-# ------------------- 2024-12-13 12:31:06 -------------------
-# path: My_Funcs/OAFuncs/oafuncs/oa_down/
-from .oa_down import *
+
 # ------------------- 2024-12-13 12:31:06 -------------------
 # path: My_Funcs/OAFuncs/oafuncs/oa_sign/
 from .oa_sign import *
+
 # ------------------- 2024-12-13 12:31:06 -------------------
 # path: My_Funcs/OAFuncs/oafuncs/oa_tool/
 from .oa_tool import *
-# ------------------- 2024-12-13 12:31:06 -------------------
+# ------------------- 2025-03-09 16:28:01 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/_script/
+from ._script import *
+# ------------------- 2025-03-16 15:56:01 -------------------

oafuncs-0.0.97.1/oafuncs/_script/__init__.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+Author: Liu Kun && 16031215@qq.com
+Date: 2025-03-13 15:26:15
+LastEditors: Liu Kun && 16031215@qq.com
+LastEditTime: 2025-03-13 15:26:18
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_script\\__init__.py
+Description:
+EditPlatform: vscode
+ComputerInfo: XPS 15 9510
+SystemInfo: Windows 11
+Python Version: 3.12
+"""
+
+
+
+# 会导致OAFuncs直接导入所有函数，不符合模块化设计
+# from oafuncs.oa_s.oa_cmap import *
+# from oafuncs.oa_s.oa_data import *
+# from oafuncs.oa_s.oa_draw import *
+# from oafuncs.oa_s.oa_file import *
+# from oafuncs.oa_s.oa_help import *
+# from oafuncs.oa_s.oa_nc import *
+# from oafuncs.oa_s.oa_python import *
+
+from .plot_dataset import func_plot_dataset

oafuncs-0.0.97.1/oafuncs/_script/plot_dataset.py

@@ -0,0 +1,299 @@
+import os
+from typing import Optional, Tuple
+
+import matplotlib as mpl
+
+mpl.use("Agg")  # Use non-interactive backend
+
+import cftime
+import matplotlib.pyplot as plt
+import numpy as np
+from rich import print
+import cartopy.crs as ccrs
+import xarray as xr
+
+import oafuncs
+
+
+def plot_1d(data: xr.DataArray, output_path: str, x_dim: str, y_dim: str, z_dim: str, t_dim: str) -> None:
+    """Plot 1D data."""
+    plt.figure(figsize=(10, 6))
+
+    # Handle time dimension
+    if t_dim in data.dims and isinstance(data[t_dim].values[0], cftime.datetime):
+        try:
+            data[t_dim] = data.indexes[t_dim].to_datetimeindex()
+        except (AttributeError, ValueError, TypeError) as e:
+            print(f"Warning: Could not convert {t_dim} to datetime index: {e}")
+
+    # Determine X axis data
+    x, x_label = determine_x_axis(data, x_dim, y_dim, z_dim, t_dim)
+
+    y = data.values
+    plt.plot(x, y, linewidth=2)
+
+    # Add chart info
+    long_name = getattr(data, "long_name", "No long_name")
+    units = getattr(data, "units", "")
+    plt.title(f"{data.name} | {long_name}", fontsize=12)
+    plt.xlabel(x_label)
+    plt.ylabel(f"{data.name} ({units})" if units else data.name)
+
+    plt.grid(True, linestyle="--", alpha=0.7)
+    plt.tight_layout()
+
+    # Save image
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    plt.savefig(output_path, bbox_inches="tight", dpi=600)
+    plt.clf()
+    plt.close()
+
+
+def determine_x_axis(data: xr.DataArray, x_dim: str, y_dim: str, z_dim: str, t_dim: str) -> Tuple[np.ndarray, str]:
+    """Determine the X axis data and label."""
+    if x_dim in data.dims:
+        return data[x_dim].values, x_dim
+    elif y_dim in data.dims:
+        return data[y_dim].values, y_dim
+    elif z_dim in data.dims:
+        return data[z_dim].values, z_dim
+    elif t_dim in data.dims:
+        return data[t_dim].values, t_dim
+    else:
+        return np.arange(len(data)), "Index"
+
+
+def plot_2d(data: xr.DataArray, output_path: str, data_range: Optional[Tuple[float, float]], x_dim: str, y_dim: str, t_dim: str, plot_type: str) -> bool:
+    """Plot 2D data."""
+    if x_dim in data.dims and y_dim in data.dims and x_dim.lower() in ["lon", "longitude"] and y_dim.lower() in ["lat", "latitude"]:
+        lon_range = data[x_dim].values
+        lat_range = data[y_dim].values
+        lon_lat_ratio = np.abs(np.max(lon_range) - np.min(lon_range)) / (np.max(lat_range) - np.min(lat_range))
+        figsize = (10, 10 / lon_lat_ratio)
+        fig, ax = plt.subplots(figsize=figsize, subplot_kw={"projection": ccrs.PlateCarree()})
+        oafuncs.oa_draw.add_cartopy(ax, lon_range, lat_range)
+    else:
+        fig, ax = plt.subplots(figsize=(10, 8))
+
+    # Handle time dimension
+    if t_dim in data.dims and isinstance(data[t_dim].values[0], cftime.datetime):
+        try:
+            data[t_dim] = data.indexes[t_dim].to_datetimeindex()
+        except (AttributeError, ValueError, TypeError) as e:
+            print(f"Warning: Could not convert {t_dim} to datetime index: {e}")
+
+    # Check for valid data
+    if np.all(np.isnan(data.values)) or data.size == 0:
+        print(f"Skipping {data.name}: All values are NaN or empty")
+        plt.close()
+        return False
+
+    data_range = calculate_data_range(data, data_range)
+
+    if data_range is None:
+        print(f"Skipping {data.name} due to all NaN values")
+        plt.close()
+        return False
+
+    # Select appropriate colormap and levels
+    cmap, norm, levels = select_colormap_and_levels(data_range, plot_type)
+
+    mappable = None
+    try:
+        if plot_type == "contourf":
+            if np.ptp(data.values) < 1e-10 and not np.all(np.isnan(data.values)):
+                print(f"Warning: {data.name} has very little variation. Using imshow instead.")
+                mappable = ax.imshow(data.values, cmap=cmap, aspect="auto", interpolation="none")
+                colorbar = plt.colorbar(mappable, ax=ax)
+            else:
+                mappable = ax.contourf(data[x_dim], data[y_dim], data.values, levels=levels, cmap=cmap, norm=norm)
+                colorbar = plt.colorbar(mappable, ax=ax)
+        elif plot_type == "contour":
+            if np.ptp(data.values) < 1e-10 and not np.all(np.isnan(data.values)):
+                print(f"Warning: {data.name} has very little variation. Using imshow instead.")
+                mappable = ax.imshow(data.values, cmap=cmap, aspect="auto", interpolation="none")
+                colorbar = plt.colorbar(mappable, ax=ax)
+            else:
+                mappable = ax.contour(data[x_dim], data[y_dim], data.values, levels=levels, cmap=cmap, norm=norm)
+                ax.clabel(mappable, inline=True, fontsize=8, fmt="%1.1f")
+                colorbar = plt.colorbar(mappable, ax=ax)
+    except (ValueError, TypeError) as e:
+        print(f"Warning: Could not plot with specified parameters: {e}. Trying simplified parameters.")
+        try:
+            mappable = data.plot(ax=ax, cmap=cmap, add_colorbar=False)
+            colorbar = plt.colorbar(mappable, ax=ax)
+        except Exception as e2:
+            print(f"Error plotting {data.name}: {e2}")
+            plt.figure(figsize=(10, 8))
+            mappable = ax.imshow(data.values, cmap="viridis", aspect="auto")
+            colorbar = plt.colorbar(mappable, ax=ax, label=getattr(data, "units", ""))
+            plt.title(f"{data.name} | {getattr(data, 'long_name', 'No long_name')} (basic plot)", fontsize=12)
+            plt.tight_layout()
+            os.makedirs(os.path.dirname(output_path), exist_ok=True)
+            plt.savefig(output_path, bbox_inches="tight", dpi=600)
+            plt.close()
+            return True
+
+    plt.title(f"{data.name} | {getattr(data, 'long_name', 'No long_name')}", fontsize=12)
+    units = getattr(data, "units", "")
+    if units and colorbar:
+        colorbar.set_label(units)
+
+    plt.tight_layout()
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    plt.savefig(output_path, bbox_inches="tight", dpi=600)
+    plt.close()
+    return True
+
+
+def calculate_data_range(data: xr.DataArray, data_range: Optional[Tuple[float, float]]) -> Optional[Tuple[float, float]]:
+    """Calculate the data range, ignoring extreme outliers."""
+    if data_range is None:
+        flat_data = data.values.flatten()
+        if flat_data.size == 0:
+            return None
+        valid_data = flat_data[~np.isnan(flat_data)]
+        if len(valid_data) == 0:
+            return None
+        low, high = np.percentile(valid_data, [0.5, 99.5])
+        filtered_data = valid_data[(valid_data >= low) & (valid_data <= high)]
+        if len(filtered_data) > 0:
+            data_range = (np.min(filtered_data), np.max(filtered_data))
+        else:
+            data_range = (np.nanmin(valid_data), np.nanmax(valid_data))
+        if abs(data_range[1] - data_range[0]) < 1e-10:
+            mean = (data_range[0] + data_range[1]) / 2
+            data_range = (mean - 1e-10 if mean != 0 else -1e-10, mean + 1e-10 if mean != 0 else 1e-10)
+    return data_range
+
+
+def select_colormap_and_levels(data_range: Tuple[float, float], plot_type: str) -> Tuple[mpl.colors.Colormap, mpl.colors.Normalize, np.ndarray]:
+    """Select colormap and levels based on data range."""
+    if plot_type == "contour":
+        # For contour plots, use fewer levels
+        num_levels = 10
+    else:
+        # For filled contour plots, use more levels
+        num_levels = 128
+
+    if data_range[0] * data_range[1] < 0:
+        cmap = oafuncs.oa_cmap.get("diverging_1")
+        bdy = max(abs(data_range[0]), abs(data_range[1]))
+        norm = mpl.colors.TwoSlopeNorm(vmin=-bdy, vcenter=0, vmax=bdy)
+        levels = np.linspace(-bdy, bdy, num_levels)
+    else:
+        cmap = oafuncs.oa_cmap.get("cool_1") if data_range[0] < 0 else oafuncs.oa_cmap.get("warm_1")
+        norm = mpl.colors.Normalize(vmin=data_range[0], vmax=data_range[1])
+        levels = np.linspace(data_range[0], data_range[1], num_levels)
+
+    if np.any(np.diff(levels) <= 0):
+        levels = np.linspace(data_range[0], data_range[1], 10)
+    return cmap, norm, levels
+
+
+def process_variable(var: str, data: xr.DataArray, dims: int, dims_name: Tuple[str, ...], output_dir: str, x_dim: str, y_dim: str, z_dim: str, t_dim: str, fixed_colorscale: bool, plot_type: str) -> None:
+    """Process a single variable."""
+    valid_dims = {x_dim, y_dim, z_dim, t_dim}
+    if not set(dims_name).issubset(valid_dims):
+        print(f"Skipping {var} due to unsupported dimensions: {dims_name}")
+        return
+
+    # Process 1D data
+    if dims == 1:
+        if np.issubdtype(data.dtype, np.character):
+            print(f"Skipping {var} due to character data type")
+            return
+        plot_1d(data, os.path.join(output_dir, f"{var}.png"), x_dim, y_dim, z_dim, t_dim)
+        print(f"{var}.png")
+        return
+
+    # Compute global data range for fixed colorscale
+    global_data_range = None
+    if dims >= 2 and fixed_colorscale:
+        global_data_range = calculate_data_range(data, None)
+        if global_data_range is None:
+            print(f"Skipping {var} due to no valid data")
+            return
+        print(f"Fixed colorscale range: {global_data_range}")
+
+    # Process 2D data
+    if dims == 2:
+        success = plot_2d(data, os.path.join(output_dir, f"{var}.png"), global_data_range, x_dim, y_dim, t_dim, plot_type)
+        if success:
+            print(f"{var}.png")
+
+    # Process 3D data
+    if dims == 3:
+        for i in range(data.shape[0]):
+            for attempt in range(10):
+                try:
+                    if data[i].values.size == 0:
+                        print(f"Skipped {var}_{dims_name[0]}-{i} (empty data)")
+                        break
+                    success = plot_2d(data[i], os.path.join(output_dir, f"{var}_{dims_name[0]}-{i}.png"), global_data_range, x_dim, y_dim, t_dim, plot_type)
+                    if success:
+                        print(f"{var}_{dims_name[0]}-{i}.png")
+                    else:
+                        print(f"Skipped {var}_{dims_name[0]}-{i} (invalid data)")
+                    break
+                except Exception as e:
+                    if attempt < 9:
+                        print(f"Retrying {var}_{dims_name[0]}-{i} (attempt {attempt + 1})")
+                    else:
+                        print(f"Error processing {var}_{dims_name[0]}-{i}: {e}")
+
+    # Process 4D data
+    if dims == 4:
+        for i in range(data.shape[0]):
+            for j in range(data.shape[1]):
+                for attempt in range(3):
+                    try:
+                        if data[i, j].values.size == 0:
+                            print(f"Skipped {var}_{dims_name[0]}-{i}_{dims_name[1]}-{j} (empty data)")
+                            break
+                        success = plot_2d(data[i, j], os.path.join(output_dir, f"{var}_{dims_name[0]}-{i}_{dims_name[1]}-{j}.png"), global_data_range, x_dim, y_dim, t_dim, plot_type)
+                        if success:
+                            print(f"{var}_{dims_name[0]}-{i}_{dims_name[1]}-{j}.png")
+                        else:
+                            print(f"Skipped {var}_{dims_name[0]}-{i}_{dims_name[1]}-{j} (invalid data)")
+                        break
+                    except Exception as e:
+                        if attempt < 2:
+                            print(f"Retrying {var}_{dims_name[0]}-{i}_{dims_name[1]}-{j} (attempt {attempt + 1})")
+                        else:
+                            print(f"Error processing {var}_{dims_name[0]}-{i}_{dims_name[1]}-{j}: {e}")
+
+
+def func_plot_dataset(ds_in: xr.Dataset, output_dir: str, xyzt_dims: Tuple[str, str, str, str] = ("longitude", "latitude", "level", "time"), 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:
+        ds = ds_in
+        varlist = list(ds.data_vars)
+        print(f"Found {len(varlist)} variables in dataset")
+
+        for var in varlist:
+            print("=" * 120)
+            print(f"Processing: {var}")
+            data = ds[var]
+            dims = len(data.shape)
+            dims_name = data.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:
+                print(f"Error processing variable {var}: {e}")
+
+    except Exception as e:
+        print(f"Error processing dataset: {e}")
+    finally:
+        if "ds" in locals():
+            ds.close()
+            print("Dataset closed")
+
+
+if __name__ == "__main__":
+    pass
+    # func_plot_dataset(ds, output_dir, xyzt_dims=("longitude", "latitude", "level", "time"), plot_type="contourf", fixed_colorscale=False)

{oafuncs-0.0.96 → oafuncs-0.0.97.1}/oafuncs/oa_cmap.py

@@ -143,14 +143,14 @@ def get(cmap_name=None, query=False):
     Example:
         cmap = get('viridis')
         cmap = get('diverging_1')
-        cmap = get('cold_1')
+        cmap = get('cool_1')
         cmap = get('warm_1')
         cmap = get('colorful_1')
     """
 
     my_cmap_dict = {
         "diverging_1": create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"]),
-        "cold_1": create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC"]),
+        "cool_1": create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC"]),
         "warm_1": create(["#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"]),
         # "land_1": create_custom(["#3E6436", "#678A59", "#91A176", "#B8A87D", "#D9CBB2"], under="#A6CEE3", over="#FFFFFF"),
         # "ocean_1": create_custom(["#126697", "#2D88B3", "#4EA1C9", "#78B9D8", "#A6CEE3"], under="#8470FF", over="#3E6436"), 
@@ -191,7 +191,9 @@ def get(cmap_name=None, query=False):
         try:
             return mpl.colormaps.get_cmap(cmap_name)
         except ValueError:
-            raise ValueError(f"Unknown cmap name: {cmap_name}")
+            # raise ValueError(f"Unknown cmap name: {cmap_name}")
+            print(f"Unknown cmap name: {cmap_name}\nNow return 'rainbow' as default.")
+            return mpl.colormaps.get_cmap("rainbow")
 
 
 if __name__ == "__main__":

{oafuncs-0.0.96 → oafuncs-0.0.97.1}/oafuncs/oa_data.py

@@ -18,11 +18,12 @@ import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor
 
 import numpy as np
+import salem
 import xarray as xr
 from scipy.interpolate import griddata
-import salem
+from scipy.interpolate import interp1d
 
-__all__ = ["interp_2d", "ensure_list", "mask_shapefile"]
+__all__ = ["interp_along_dim", "interp_2d", "ensure_list", "mask_shapefile"]
 
 
 def ensure_list(input_data):
@@ -45,15 +46,126 @@ def ensure_list(input_data):
         return [str(input_data)]
 
 
+def interp_along_dim(tgt_coords, src_coords, src_data, axis=-1, interp_method="linear", extrap_method="linear"):
+    """
+    在指定维度上执行插值和外插操作。
+
+    Parameters:
+    -----------
+    tgt_coords: 1d array
+        目标坐标点数组，必须是一维数组。
+
+    src_coords: 1d or nd array
+        源坐标点数组。可以是一维数组（将被广播到与src_data匹配的形状）或与src_data相同形状的多维数组。
+
+    src_data: nd array
+        源数据数组，包含要从src_coords插值到tgt_coords的现象值。
+
+    axis: int (default -1)
+        要在src_data上执行插值的轴。默认为最后一个轴。
+
+    interp_method: str (default "linear")
+        核心插值方法。
+        可选值包括:
+        - "linear": 线性插值（默认）
+        - "nearest": 最近邻插值
+        - "zero": 零阶插值
+        - "slinear": 样条一阶插值
+        - "quadratic": 二阶插值
+        - "cubic": 三阶插值
+        - "previous": 使用前一个点的值
+        - "next": 使用后一个点的值
+        更多选项参考scipy.interpolate.interp1d的kind参数。
+
+    extrap_method: str (default "linear")
+        核心外插方法，用于处理超出源坐标范围的目标坐标点。
+        支持与interp_method相同的选项:
+        - "linear": 线性外插（默认）
+        - "nearest": 最近邻外插
+        - "zero": 零阶外插
+        - "slinear": 样条一阶外插
+        - "quadratic": 二阶外插
+        - "cubic": 三阶外插
+        - "previous": 使用最近的前一个点的值
+        - "next": 使用最近的后一个点的值
+
+    Returns:
+    --------
+    array
+        插值后的数据数组，形状将与src_data相同，但在axis轴上长度为len(tgt_coords)。
+
+    Examples:
+    ---------
+    1D插值示例:
+    >>> tgt_coords = np.array([1, 2, 3, 4])
+    >>> src_coords = np.array([0, 1, 2, 3, 4, 5])
+    >>> src_data = np.array([0, 1, 4, 9, 16, 25])
+    >>> interp_along_dim(tgt_coords, src_coords, src_data)
+    array([ 1.,  4.,  9., 16.])
+
+    多维插值示例:
+    >>> src_data = np.array([[0, 1, 4], [10, 20, 30]])
+    >>> interp_along_dim(np.array([0.5, 1.5]), np.array([0, 1, 2]), src_data, axis=1)
+    array([[ 0.5,  2.5],
+           [15. , 25. ]])
+    """
+    tgt_coords = np.asarray(tgt_coords)
+    if tgt_coords.ndim != 1:
+        raise ValueError("tgt_coords must be a 1d array.")
+
+    src_coords = np.asarray(src_coords)
+    src_data = np.asarray(src_data)
+
+    # 处理1维的简单情况
+    if src_data.ndim == 1 and src_coords.ndim == 1:
+        if len(src_coords) != len(src_data):
+            raise ValueError("For 1D data, src_coords and src_data must have the same length")
+
+        interpolator = interp1d(src_coords, src_data, kind=interp_method, fill_value="extrapolate", bounds_error=False)
+        return interpolator(tgt_coords)
+
+    # 多维情况的处理
+    if src_coords.ndim == 1:
+        # Expand src_coords to match src_data dimensions along the specified axis
+        shape = [1] * src_data.ndim
+        shape[axis] = src_coords.shape[0]
+        src_coords = np.reshape(src_coords, shape)
+        src_coords = np.broadcast_to(src_coords, src_data.shape)
+    elif src_coords.shape != src_data.shape:
+        raise ValueError("src_coords and src_data must have the same shape.")
+
+    def apply_interp_extrap(arr):
+        xp = np.moveaxis(src_coords, axis, 0)
+        # 根据维度正确获取坐标
+        if xp.ndim > 1:
+            xp = xp[:, 0]  # 多维情况
+        else:
+            xp = xp  # 1维情况
+
+        arr = np.moveaxis(arr, axis, 0)
+        interpolator = interp1d(xp, arr, kind=interp_method, fill_value="extrapolate", bounds_error=False)
+        interpolated = interpolator(tgt_coords)
+        if extrap_method != interp_method:
+            mask_extrap = (tgt_coords < xp.min()) | (tgt_coords > xp.max())
+            if np.any(mask_extrap):
+                extrap_interpolator = interp1d(xp, arr, kind=extrap_method, fill_value="extrapolate", bounds_error=False)
+                interpolated[mask_extrap] = extrap_interpolator(tgt_coords[mask_extrap])
+        return np.moveaxis(interpolated, 0, axis)
+
+    result = np.apply_along_axis(apply_interp_extrap, axis, src_data)
+
+    return result
+
+
 def interp_2d(target_x, target_y, origin_x, origin_y, data, method="linear", parallel=True):
     """
     Perform 2D interpolation on the last two dimensions of a multi-dimensional array.
 
     Parameters:
-    - target_x (array-like): 1D array of target grid's x-coordinates.
-    - target_y (array-like): 1D array of target grid's y-coordinates.
-    - origin_x (array-like): 1D array of original grid's x-coordinates.
-    - origin_y (array-like): 1D array of original grid's y-coordinates.
+    - target_x (array-like): 1D or 2D array of target grid's x-coordinates.
+    - target_y (array-like): 1D or 2D array of target grid's y-coordinates.
+    - origin_x (array-like): 1D or 2D array of original grid's x-coordinates.
+    - origin_y (array-like): 1D or 2D array of original grid's y-coordinates.
     - data (numpy.ndarray): Multi-dimensional array where the last two dimensions correspond to the original grid.
     - method (str, optional): Interpolation method, default is 'linear'. Other options include 'nearest', 'cubic', etc.
     - parallel (bool, optional): Flag to enable parallel processing. Default is True.