oafuncs 0.0.80__py2.py3-none-any.whl → 0.0.82__py2.py3-none-any.whl

oafuncs/__init__.py

@@ -4,26 +4,41 @@
 Author: Liu Kun && 16031215@qq.com
 Date: 2024-09-17 16:09:20
 LastEditors: Liu Kun && 16031215@qq.com
-LastEditTime: 2024-12-13 10:56:43
-FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\__init__.py
+LastEditTime: 2024-12-13 12:31:06
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_s\\__init__.py
 Description:
 EditPlatform: vscode
 ComputerInfo: XPS 15 9510
 SystemInfo: Windows 11
-Python Version: 3.11
+Python Version: 3.12
 """
 
+
 # 会导致OAFuncs直接导入所有函数，不符合模块化设计
-from oafuncs.oa_s import (
-    oa_cmap,
-    oa_data,
-    oa_draw,
-    oa_file,
-    oa_help,
-    oa_nc,
-    oa_python,
-)
+# 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 *
 
+# ------------------- 2024-12-13 12:31:06 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/
+from .oa_cmap import *
+from .oa_data import *
+from .oa_draw import *
+from .oa_file import *
+from .oa_help 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 -------------------

oafuncs/oa_cmap.py

@@ -17,11 +17,9 @@ import matplotlib as mpl
 import matplotlib.pyplot as plt
 import numpy as np
 
-__all__ = ["show", "extract_colors", "create_custom", "create_diverging", "create_5rgb_txt", "my_cmap"]
+__all__ = ["show", "cmap2colors", "create_cmap", "create_cmap_rgbtxt", "choose_cmap"]
 
 # ** 将cmap用填色图可视化（官网摘抄函数）
-
-
 def show(colormaps: list):
     """
     Helper function to plot data with associated colormap.
@@ -40,28 +38,28 @@ def show(colormaps: list):
 
 
 # ** 将cmap转为list，即多个颜色的列表
-def extract_colors(cmap, n=256):
+def cmap2colors(cmap, n=256):
     """
     cmap        : cmap名称
     n           : 提取颜色数量
     return      : 提取的颜色列表
-    example     : out_cmap = extract_colors('viridis', 256)
+    example     : out_colors = cmap2colors('viridis', 256)
     """
     c_map = mpl.colormaps.get_cmap(cmap)
-    out_cmap = [c_map(i) for i in np.linspace(0, 1, n)]
-    return out_cmap
+    out_colors = [c_map(i) for i in np.linspace(0, 1, n)]
+    return out_colors
 
 
 # ** 自制cmap，多色，可带位置
-def create_custom(colors: list, nodes=None, under=None, over=None):  # 利用颜色快速配色
+def create_cmap(colors: list, nodes=None, under=None, over=None):  # 利用颜色快速配色
     """
     func        : 自制cmap，自动确定颜色位置（等比例）
     description : colors可以是颜色名称，也可以是十六进制颜色代码
     param        {*} colors 颜色
     param        {*} nodes 颜色位置，默认不提供，等间距
-    return       {*} c_map
-    example     : c_map = mk_cmap(['#C2B7F3','#B3BBF2','#B0CBF1','#ACDCF0','#A8EEED'])
-                c_map = mk_cmap(['aliceblue','skyblue','deepskyblue'],[0.0,0.5,1.0])
+    return       {*} cmap
+    example     : cmap = create_cmap(['#C2B7F3','#B3BBF2','#B0CBF1','#ACDCF0','#A8EEED'])
+                cmap = create_cmap(['aliceblue','skyblue','deepskyblue'],[0.0,0.5,1.0])
     """
     if nodes is None:  # 采取自动分配比例
         cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", colors)
@@ -74,46 +72,27 @@ def create_custom(colors: list, nodes=None, under=None, over=None):  # 利用颜
     return cmap_color
 
 
-# ** 自制diverging型cmap，默认中间为白色
-
-
-def create_diverging(colors: list):
-    """
-    func        : 自制cmap，双色，中间默认为白色；如果输入偶数个颜色，则中间为白，如果奇数个颜色，则中间色为中间色
-    description : colors可以是颜色名称，也可以是十六进制颜色代码
-    param        {*} colors
-    return       {*}
-    example     : diverging_cmap = mk_cmap_diverging(["#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247"])
-    """
-    # 自定义颜色位置
-    n = len(colors)
-    nodes = np.linspace(0.0, 1.0, n + 1 if n % 2 == 0 else n)
-    newcolors = colors
-    if n % 2 == 0:
-        newcolors.insert(int(n / 2), "#ffffff")  # 偶数个颜色，中间为白色
-    cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", list(zip(nodes, newcolors)))
-    return cmap_color
-
-
 # ** 根据RGB的txt文档制作色卡（利用Grads调色盘）
-
-
-def create_5rgb_txt(rgb_txt_filepath: str):  # 根据RGB的txt文档制作色卡/根据rgb值制作
+def create_cmap_rgbtxt(rgbtxt_file,split_mark=','):  # 根据RGB的txt文档制作色卡/根据rgb值制作
     """
     func        : 根据RGB的txt文档制作色卡
-    description : rgb_txt_filepath='E:/python/colorbar/test.txt'
-    param        {*} rgb_txt_filepath txt文件路径
+    description : rgbtxt_file='E:/python/colorbar/test.txt'
+    param        {*} rgbtxt_file txt文件路径
     return       {*} camp
-    example     : cmap_color=dcmap(path)
+    example     : cmap=create_cmap_rgbtxt(path,split_mark=',') #
+
+    txt example : 251,251,253
+                225,125,25
+                250,205,255
     """
-    with open(rgb_txt_filepath) as fid:
+    with open(rgbtxt_file) as fid:
         data = fid.readlines()
     n = len(data)
     rgb = np.zeros((n, 3))
     for i in np.arange(n):
-        rgb[i][0] = data[i].split(",")[0]
-        rgb[i][1] = data[i].split(",")[1]
-        rgb[i][2] = data[i].split(",")[2]
+        rgb[i][0] = data[i].split(split_mark)[0]
+        rgb[i][1] = data[i].split(split_mark)[1]
+        rgb[i][2] = data[i].split(split_mark)[2]
     max_rgb = np.max(rgb)
     if max_rgb > 2:  # 如果rgb值大于2，则认为是0-255的值，需要归一化
         rgb = rgb / 255.0
@@ -121,7 +100,7 @@ def create_5rgb_txt(rgb_txt_filepath: str):  # 根据RGB的txt文档制作色卡
     return icmap
 
 
-def my_cmap(cmap_name=None, query=False):
+def choose_cmap(cmap_name=None, query=False):
     """
     description: Choosing a colormap from the list of available colormaps or a custom colormap
     param {*} cmap_name:
@@ -130,9 +109,9 @@ def my_cmap(cmap_name=None, query=False):
     """
 
     my_cmap_dict = {
-        "diverging_1": create_custom(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"]),
-        "cold_1": create_custom(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC"]),
-        "warm_1": create_custom(["#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"]),
+        "diverging_1": create_cmap(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"]),
+        "cold_1": create_cmap(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC"]),
+        "warm_1": create_cmap(["#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"), # 海洋颜色从深蓝到浅蓝，表示从深海到浅海的递减
         # "ocean_land_1": create_custom(
@@ -150,7 +129,7 @@ def my_cmap(cmap_name=None, query=False):
         #         "#3E6436",  # 深绿（高山）
         #     ]
         # ),
-        "colorful_1": create_custom(["#6d00db", "#9800cb", "#F2003C", "#ff4500", "#ff7f00", "#FE28A2", "#FFC0CB", "#DDA0DD", "#40E0D0", "#1a66f2", "#00f7fb", "#8fff88", "#E3FF00"]),
+        "colorful_1": create_cmap(["#6d00db", "#9800cb", "#F2003C", "#ff4500", "#ff7f00", "#FE28A2", "#FFC0CB", "#DDA0DD", "#40E0D0", "#1a66f2", "#00f7fb", "#8fff88", "#E3FF00"]),
     }
     if query:
         for key, _ in my_cmap_dict.items():
@@ -160,7 +139,7 @@ def my_cmap(cmap_name=None, query=False):
         return my_cmap_dict[cmap_name]
     else:
         try:
-            return mpl.cm.get_cmap(cmap_name)
+            return mpl.colormaps.get_cmap(cmap_name)
         except ValueError:
             raise ValueError(f"Unknown cmap name: {cmap_name}")
 
@@ -169,16 +148,16 @@ if __name__ == "__main__":
     # ** 测试自制cmap
     colors = ["#C2B7F3", "#B3BBF2", "#B0CBF1", "#ACDCF0", "#A8EEED"]
     nodes = [0.0, 0.2, 0.4, 0.6, 1.0]
-    c_map = create_custom(colors, nodes)
+    c_map = create_cmap(colors, nodes)
     show([c_map])
 
     # ** 测试自制diverging型cmap
-    diverging_cmap = create_diverging(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"])
+    diverging_cmap = create_cmap(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"])
     show([diverging_cmap])
 
     # ** 测试根据RGB的txt文档制作色卡
     file_path = "E:/python/colorbar/test.txt"
-    cmap_color = create_5rgb_txt(file_path)
+    cmap_rgb = create_cmap_rgbtxt(file_path)
 
     # ** 测试将cmap转为list
-    out_cmap = extract_colors("viridis", 256)
+    out_colors = cmap2colors("viridis", 256)

oafuncs/oa_data.py

@@ -1,31 +1,97 @@
 #!/usr/bin/env python
 # coding=utf-8
-'''
+"""
 Author: Liu Kun && 16031215@qq.com
 Date: 2024-09-17 17:12:47
 LastEditors: Liu Kun && 16031215@qq.com
-LastEditTime: 2024-11-21 13:13:20
+LastEditTime: 2024-12-13 19:11:08
 FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_data.py
-Description:  
+Description:
 EditPlatform: vscode
 ComputerInfo: XPS 15 9510
 SystemInfo: Windows 11
 Python Version: 3.11
-'''
-
+"""
 
+import itertools
 import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor
 
 import numpy as np
 from scipy.interpolate import griddata
 
-__all__ = ['interp_2d', 'interp_2d_parallel']
+__all__ = ["interp_2d"]
 
-# ** 高维插值函数，插值最后两个维度
 
+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.
+    - 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.
+
+    Returns:
+    - interpolated_data (numpy.ndarray): Interpolated data with the same leading dimensions as the input data, but with the last two dimensions corresponding to the target grid.
+
+    Raises:
+    - ValueError: If the shape of the data does not match the shape of the origin_x or origin_y grids.
+
+    Usage:
+    - Interpolate a 2D array:
+        result = interp_2d(target_x, target_y, origin_x, origin_y, data_2d)
+    - Interpolate a 3D array (where the last two dimensions are spatial):
+        result = interp_2d(target_x, target_y, origin_x, origin_y, data_3d)
+    - Interpolate a 4D array (where the last two dimensions are spatial):
+        result = interp_2d(target_x, target_y, origin_x, origin_y, data_4d)
+    """
+
+    def interp_single(data_slice, target_points, origin_points, method):
+        return griddata(origin_points, data_slice.ravel(), target_points, method=method).reshape(target_y.shape)
+
+    # 确保目标网格和初始网格都是二维的
+    if len(target_y.shape) == 1:
+        target_x, target_y = np.meshgrid(target_x, target_y)
+    if len(origin_y.shape) == 1:
+        origin_x, origin_y = np.meshgrid(origin_x, origin_y)
+
+    # 根据经纬度网格判断输入数据的形状是否匹配
+    if origin_x.shape != data.shape[-2:] or origin_y.shape != data.shape[-2:]:
+        raise ValueError("Shape of data does not match shape of origin_x or origin_y.")
+
+    # 创建网格和展平数据
+    target_points = np.column_stack((target_y.ravel(), target_x.ravel()))
+    origin_points = np.column_stack((origin_y.ravel(), origin_x.ravel()))
+
+    # 根据是否并行选择不同的执行方式
+    if parallel:
+        with ThreadPoolExecutor(max_workers=mp.cpu_count() - 2) as executor:
+            if len(data.shape) == 2:
+                interpolated_data = list(executor.map(interp_single, [data], [target_points], [origin_points], [method]))
+            elif len(data.shape) == 3:
+                interpolated_data = list(executor.map(interp_single, [data[i] for i in range(data.shape[0])], [target_points] * data.shape[0], [origin_points] * data.shape[0], [method] * data.shape[0]))
+            elif len(data.shape) == 4:
+                index_combinations = list(itertools.product(range(data.shape[0]), range(data.shape[1])))
+                interpolated_data = list(executor.map(interp_single, [data[i, j] for i, j in index_combinations], [target_points] * len(index_combinations), [origin_points] * len(index_combinations), [method] * len(index_combinations)))
+                interpolated_data = np.array(interpolated_data).reshape(data.shape[0], data.shape[1], *target_y.shape)
+    else:
+        if len(data.shape) == 2:
+            interpolated_data = interp_single(data, target_points, origin_points, method)
+        elif len(data.shape) == 3:
+            interpolated_data = np.stack([interp_single(data[i], target_points, origin_points, method) for i in range(data.shape[0])])
+        elif len(data.shape) == 4:
+            interpolated_data = np.stack([np.stack([interp_single(data[i, j], target_points, origin_points, method) for j in range(data.shape[1])]) for i in range(data.shape[0])])
+
+    return np.array(interpolated_data)
 
-def interp_2d(target_x, target_y, origin_x, origin_y, data, method='linear'):
+
+# ** 高维插值函数，插值最后两个维度
+def interp_2d_20241213(target_x, target_y, origin_x, origin_y, data, method="linear"):
     """
     高维插值函数，默认插值最后两个维度，传输数据前请确保数据的维度正确
     参数:
@@ -52,7 +118,7 @@ def interp_2d(target_x, target_y, origin_x, origin_y, data, method='linear'):
 
     if origin_x.shape != dims[-2:] or origin_y.shape != dims[-2:]:
         print(origin_x.shape, dims[-2:])
-        raise ValueError('Shape of data does not match shape of origin_x or origin_y.')
+        raise ValueError("Shape of data does not match shape of origin_x or origin_y.")
 
     # 将目标网格展平成一维数组
     target_points = np.column_stack((np.ravel(target_y), np.ravel(target_x)))
@@ -69,7 +135,7 @@ def interp_2d(target_x, target_y, origin_x, origin_y, data, method='linear'):
         for i in range(dims[0]):
             dt = griddata(origin_points, np.ravel(data[i, :, :]), target_points, method=method)
             interpolated_data.append(np.reshape(dt, target_y.shape))
-            print(f'Interpolating {i+1}/{dims[0]}...')
+            print(f"Interpolating {i+1}/{dims[0]}...")
         interpolated_data = np.array(interpolated_data)
     elif len_dims == 4:
         interpolated_data = []
@@ -78,8 +144,8 @@ def interp_2d(target_x, target_y, origin_x, origin_y, data, method='linear'):
             for j in range(dims[1]):
                 dt = griddata(origin_points, np.ravel(data[i, j, :, :]), target_points, method=method)
                 interpolated_data[i].append(np.reshape(dt, target_y.shape))
-                print(f'\rInterpolating {i*dims[1]+j+1}/{dims[0]*dims[1]}...', end='')
-        print('\n')
+                print(f"\rInterpolating {i*dims[1]+j+1}/{dims[0]*dims[1]}...", end="")
+        print("\n")
         interpolated_data = np.array(interpolated_data)
 
     return interpolated_data
@@ -87,8 +153,8 @@ def interp_2d(target_x, target_y, origin_x, origin_y, data, method='linear'):
 
 # ** 高维插值函数，插值最后两个维度，使用多线程进行插值
 # 在本地电脑上可以提速三倍左右，超算上暂时无法加速
-def interp_2d_parallel(target_x, target_y, origin_x, origin_y, data, method='linear'):
-    '''
+def interp_2d_parallel_20241213(target_x, target_y, origin_x, origin_y, data, method="linear"):
+    """
     param        {*} target_x 目标经度网格 1D 或 2D
     param        {*} target_y 目标纬度网格 1D 或 2D
     param        {*} origin_x 初始经度网格 1D 或 2D
@@ -98,22 +164,23 @@ def interp_2d_parallel(target_x, target_y, origin_x, origin_y, data, method='lin
     return       {*} 插值结果
     description : 高维插值函数，默认插值最后两个维度，传输数据前请确保数据的维度正确
     example     : interpolated_data = interp_2d_parallel(target_x, target_y, origin_x, origin_y, data, method='linear')
-    '''
-    def interp_single2d(target_y, target_x, origin_y, origin_x, data, method='linear'):
+    """
+
+    def interp_single2d(target_y, target_x, origin_y, origin_x, data, method="linear"):
         target_points = np.column_stack((np.ravel(target_y), np.ravel(target_x)))
         origin_points = np.column_stack((np.ravel(origin_y), np.ravel(origin_x)))
 
         dt = griddata(origin_points, np.ravel(data[:, :]), target_points, method=method)
         return np.reshape(dt, target_y.shape)
 
-    def interp_single3d(i, target_y, target_x, origin_y, origin_x, data, method='linear'):
+    def interp_single3d(i, target_y, target_x, origin_y, origin_x, data, method="linear"):
         target_points = np.column_stack((np.ravel(target_y), np.ravel(target_x)))
         origin_points = np.column_stack((np.ravel(origin_y), np.ravel(origin_x)))
 
         dt = griddata(origin_points, np.ravel(data[i, :, :]), target_points, method=method)
         return np.reshape(dt, target_y.shape)
 
-    def interp_single4d(i, j, target_y, target_x, origin_y, origin_x, data, method='linear'):
+    def interp_single4d(i, j, target_y, target_x, origin_y, origin_x, data, method="linear"):
         target_points = np.column_stack((np.ravel(target_y), np.ravel(target_x)))
         origin_points = np.column_stack((np.ravel(origin_y), np.ravel(origin_x)))
 
@@ -129,19 +196,31 @@ def interp_2d_parallel(target_x, target_y, origin_x, origin_y, data, method='lin
     len_dims = len(dims)
 
     if origin_x.shape != dims[-2:] or origin_y.shape != dims[-2:]:
-        raise ValueError('数据形状与 origin_x 或 origin_y 的形状不匹配.')
+        raise ValueError("数据形状与 origin_x 或 origin_y 的形状不匹配.")
 
     interpolated_data = []
 
     # 使用多线程进行插值
-    with ThreadPoolExecutor(max_workers=mp.cpu_count()-2) as executor:
-        print(f'Using {mp.cpu_count()-2} threads...')
+    with ThreadPoolExecutor(max_workers=mp.cpu_count() - 2) as executor:
+        print(f"Using {mp.cpu_count()-2} threads...")
         if len_dims == 2:
             interpolated_data = list(executor.map(interp_single2d, [target_y], [target_x], [origin_y], [origin_x], [data], [method]))
         elif len_dims == 3:
-            interpolated_data = list(executor.map(interp_single3d, [i for i in range(dims[0])], [target_y]*dims[0], [target_x]*dims[0], [origin_y]*dims[0], [origin_x]*dims[0], [data]*dims[0], [method]*dims[0]))
+            interpolated_data = list(executor.map(interp_single3d, [i for i in range(dims[0])], [target_y] * dims[0], [target_x] * dims[0], [origin_y] * dims[0], [origin_x] * dims[0], [data] * dims[0], [method] * dims[0]))
         elif len_dims == 4:
-            interpolated_data = list(executor.map(interp_single4d, [i for i in range(dims[0]) for j in range(dims[1])], [j for i in range(dims[0]) for j in range(dims[1])], [target_y]*dims[0]*dims[1], [target_x]*dims[0]*dims[1], [origin_y]*dims[0]*dims[1], [origin_x]*dims[0]*dims[1], [data]*dims[0]*dims[1], [method]*dims[0]*dims[1]))
+            interpolated_data = list(
+                executor.map(
+                    interp_single4d,
+                    [i for i in range(dims[0]) for j in range(dims[1])],
+                    [j for i in range(dims[0]) for j in range(dims[1])],
+                    [target_y] * dims[0] * dims[1],
+                    [target_x] * dims[0] * dims[1],
+                    [origin_y] * dims[0] * dims[1],
+                    [origin_x] * dims[0] * dims[1],
+                    [data] * dims[0] * dims[1],
+                    [method] * dims[0] * dims[1],
+                )
+            )
             interpolated_data = np.array(interpolated_data).reshape(dims[0], dims[1], target_y.shape[0], target_x.shape[1])
 
     interpolated_data = np.array(interpolated_data)
@@ -149,7 +228,7 @@ def interp_2d_parallel(target_x, target_y, origin_x, origin_y, data, method='lin
     return interpolated_data
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     import time
 
     import matplotlib.pyplot as plt
@@ -169,15 +248,15 @@ if __name__ == '__main__':
     data = np.random.rand(10, 10, 11, 11)
 
     start = time.time()
-    interpolated_data = interp_2d(target_x, target_y, origin_x, origin_y, data)
-    print(f'Interpolation time: {time.time()-start:.2f}s')
+    interpolated_data = interp_2d(target_x, target_y, origin_x, origin_y, data, parallel=False)
+    print(f"Interpolation time: {time.time()-start:.2f}s")
 
     print(interpolated_data.shape)
 
     # 高维插值多线程
     start = time.time()
-    interpolated_data = interp_2d_parallel(target_x, target_y, origin_x, origin_y, data)
-    print(f'Interpolation time: {time.time()-start:.2f}s')
+    interpolated_data = interp_2d(target_x, target_y, origin_x, origin_y, data)
+    print(f"Interpolation time: {time.time()-start:.2f}s")
 
     print(interpolated_data.shape)
     print(interpolated_data[0, 0, :, :].shape)