oafuncs 0.0.84__tar.gz → 0.0.86__tar.gz

{oafuncs-0.0.84/oafuncs.egg-info → oafuncs-0.0.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: oafuncs
-Version: 0.0.84
+Version: 0.0.86
 Summary: My short description for my project.
 Home-page: https://github.com/Industry-Pays/OAFuncs
 Author: Kun Liu

oafuncs-0.0.86/oafuncs/oa_cmap.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+Author: Liu Kun && 16031215@qq.com
+Date: 2024-09-17 16:55:11
+LastEditors: Liu Kun && 16031215@qq.com
+LastEditTime: 2024-11-21 13:14:24
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_cmap.py
+Description:
+EditPlatform: vscode
+ComputerInfo: XPS 15 9510
+SystemInfo: Windows 11
+Python Version: 3.11
+"""
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import numpy as np
+from rich import print
+
+__all__ = ["show", "to_color", "create", "create_rgbtxt", "get"]
+
+# ** 将cmap用填色图可视化（官网摘抄函数）
+def show(colormaps):
+    """
+    Description:
+        Helper function to plot data with associated colormap.
+    Parameters:
+        colormaps : list of colormaps, or a single colormap; can be a string or a colormap object.
+    Example:
+        cmap = ListedColormap(["darkorange", "gold", "lawngreen", "lightseagreen"])
+        show([cmap]); show("viridis"); show(["viridis", "cividis"])
+    """
+    if isinstance(colormaps, str) or isinstance(colormaps, mpl.colors.Colormap):
+        colormaps = [colormaps]
+    np.random.seed(19680801)
+    data = np.random.randn(30, 30)
+    n = len(colormaps)
+    fig, axs = plt.subplots(1, n, figsize=(n * 2 + 2, 3), constrained_layout=True, squeeze=False)
+    for [ax, cmap] in zip(axs.flat, colormaps):
+        psm = ax.pcolormesh(data, cmap=cmap, rasterized=True, vmin=-4, vmax=4)
+        fig.colorbar(psm, ax=ax)
+    plt.show()
+
+
+# ** 将cmap转为list，即多个颜色的列表
+def to_color(cmap, n=256):
+    """
+    Description:
+        Convert a colormap to a list of colors
+    Parameters:
+        cmap : str; the name of the colormap
+        n    : int, optional; the number of colors
+    Return:
+        out_colors : list of colors
+    Example:
+        out_colors = to_color('viridis', 256)
+    """
+    c_map = mpl.colormaps.get_cmap(cmap)
+    out_colors = [c_map(i) for i in np.linspace(0, 1, n)]
+    return out_colors
+
+
+# ** 自制cmap，多色，可带位置
+def create(colors: list, nodes=None, under=None, over=None):  # 利用颜色快速配色
+    """
+    Description:
+        Create a custom colormap
+    Parameters:
+        colors : list of colors
+        nodes  : list of positions
+        under  : color
+        over   : color
+    Return:
+        cmap : colormap
+    Example:
+        cmap = create(['#C2B7F3','#B3BBF2','#B0CBF1','#ACDCF0','#A8EEED'])
+        cmap = create(['aliceblue','skyblue','deepskyblue'],[0.0,0.5,1.0])
+    """
+
+    if nodes is None:  # 采取自动分配比例
+        cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", colors)
+    else:  # 按照提供比例分配
+        cmap_color = mpl.colors.LinearSegmentedColormap.from_list("mycmap", list(zip(nodes, colors)))
+    if under is not None:
+        cmap_color.set_under(under)
+    if over is not None:
+        cmap_color.set_over(over)
+    return cmap_color
+
+
+# ** 根据RGB的txt文档制作色卡（利用Grads调色盘）
+def create_rgbtxt(rgbtxt_file,split_mark=','):  # 根据RGB的txt文档制作色卡/根据rgb值制作
+    """
+    Description
+    -----------
+    Make a color card according to the RGB txt document, each line in the txt file is an RGB value, separated by commas, such as: 251,251,253
+    
+    Parameters
+    ----------
+    rgbtxt_file : str, the path of txt file
+    split_mark  : str, optional, default is ','; the split mark of rgb value
+
+    Returns
+    -------
+    cmap : colormap
+
+    Example
+    -------
+    cmap=create_rgbtxt(path,split_mark=',')
+    
+    txt example
+    -----------
+    251,251,253
+    225,125,25
+    250,205,255
+    """
+    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(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:  # if the value is greater than 2, it is normalized to 0-1
+        rgb = rgb / 255.0
+    my_cmap = mpl.colors.ListedColormap(rgb, name="my_color")
+    return my_cmap
+
+
+# ** 选择cmap
+def get(cmap_name=None, query=False):
+    """
+    Description:
+        Choosing a colormap from the list of available colormaps or a custom colormap
+    Parameters:
+        cmap_name : str, optional; the name of the colormap
+        query     : bool, optional; whether to query the available colormap names
+    Return:
+        cmap : colormap
+    Example:
+        cmap = get('viridis')
+        cmap = get('diverging_1')
+        cmap = get('cold_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"]),
+        "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"), 
+        # "ocean_land_1": create_custom(
+        #     [
+        #         "#126697",  # 深蓝（深海）
+        #         "#2D88B3",  # 蓝
+        #         "#4EA1C9",  # 蓝绿
+        #         "#78B9D8",  # 浅蓝（浅海）
+        #         "#A6CEE3",  # 浅蓝（近岸）
+        #         "#AAAAAA",  # 灰色（0值，海平面）
+        #         "#D9CBB2",  # 沙质土壤色（陆地开始）
+        #         "#B8A87D",  # 浅棕
+        #         "#91A176",  # 浅绿
+        #         "#678A59",  # 中绿
+        #         "#3E6436",  # 深绿（高山）
+        #     ]
+        # ),
+        "colorful_1": create(["#6d00db", "#9800cb", "#F2003C", "#ff4500", "#ff7f00", "#FE28A2", "#FFC0CB", "#DDA0DD", "#40E0D0", "#1a66f2", "#00f7fb", "#8fff88", "#E3FF00"]),
+    }
+    if query:
+        print("Available cmap names:")
+        print('-' * 20)
+        print('Defined by myself:')
+        for key, _ in my_cmap_dict.items():
+            print(key)
+        print('-' * 20)
+        print('Matplotlib built-in:')
+        print(mpl.colormaps())
+        print("-" * 20)
+    
+    if cmap_name is None:
+        return
+
+    if cmap_name in my_cmap_dict:
+        return my_cmap_dict[cmap_name]
+    else:
+        try:
+            return mpl.colormaps.get_cmap(cmap_name)
+        except ValueError:
+            raise ValueError(f"Unknown cmap name: {cmap_name}")
+
+
+if __name__ == "__main__":
+    # ** 测试自制cmap
+    colors = ["#C2B7F3", "#B3BBF2", "#B0CBF1", "#ACDCF0", "#A8EEED"]
+    nodes = [0.0, 0.2, 0.4, 0.6, 1.0]
+    c_map = create(colors, nodes)
+    show([c_map])
+
+    # ** 测试自制diverging型cmap
+    diverging_cmap = create(["#4e00b3", "#0000FF", "#00c0ff", "#a1d3ff", "#DCDCDC", "#FFD39B", "#FF8247", "#FF0000", "#FF5F9E"])
+    show([diverging_cmap])
+
+    # ** 测试根据RGB的txt文档制作色卡
+    file_path = "E:/python/colorbar/test.txt"
+    cmap_rgb = create_rgbtxt(file_path)
+
+    # ** 测试将cmap转为list
+    out_colors = to_color("viridis", 256)

{oafuncs-0.0.84 → oafuncs-0.0.86}/oafuncs/oa_data.py

@@ -15,12 +15,12 @@ Python Version: 3.11
 
 import itertools
 import multiprocessing as mp
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
 
 import numpy as np
 from scipy.interpolate import griddata
 
-__all__ = ["interp_2d"]
+__all__ = ["interp_2d","ParallelExecutor"]
 
 
 def interp_2d(target_x, target_y, origin_x, origin_y, data, method="linear", parallel=True):
@@ -90,6 +90,73 @@ def interp_2d(target_x, target_y, origin_x, origin_y, data, method="linear", par
     return np.array(interpolated_data)
 
 
+class ParallelExecutor:
+    """
+    通用并行计算类，支持多进程和多线程模式。
+
+    使用说明：
+        1. 创建实例时选择模式：
+            - mode="process" 使用多进程（适合 CPU 密集型任务）。
+            - mode="thread" 使用多线程（适合 IO 密集型任务）。
+
+        2. 调用 run 方法：
+            - 参数 func：需要并行执行的函数。
+            - 参数 param_list：参数列表，每个元素是传递给 func 的参数元组。
+
+    示例：
+        # 示例 1：计算平方
+        def compute_square(x):
+            return x * x
+
+        params = [(i,) for i in range(10)]
+        executor = ParallelExecutor(mode="process", max_workers=4)
+        results = executor.run(compute_square, params)
+        print("Results:", results)
+
+        # 示例 2：计算两数之和
+        def compute_sum(a, b):
+            return a + b
+
+        params = [(1, 2), (3, 4), (5, 6)]
+        executor = ParallelExecutor(mode="thread", max_workers=2)
+        results = executor.run(compute_sum, params)
+        print("Results:", results)
+
+    参数：
+        mode (str): 并行模式，"process" 表示多进程，"thread" 表示多线程。
+        max_workers (int): 最大并行工作数，默认为 CPU 核心数减 2。
+    """
+
+    def __init__(self, mode="process", max_workers=mp.cpu_count() - 2):
+        self.mode = mode
+        self.max_workers = max_workers
+        self.executor = ProcessPoolExecutor if mode == "process" else ThreadPoolExecutor
+
+    def run(self, func, param_list):
+        """
+        并行运行指定函数，并确保结果顺序与输入参数顺序一致。
+
+        参数：
+            func (callable): 需要并行执行的函数。
+            param_list (list): 参数列表，每个元素是传递给 func 的参数元组。
+
+        返回：
+            results (list): 按输入顺序返回的结果。
+        """
+        results = [None] * len(param_list)  # 预分配结果数组
+
+        with self.executor(max_workers=self.max_workers) as executor:
+            # 提交任务并保存其索引
+            future_to_index = {executor.submit(func, *params): idx for idx, params in enumerate(param_list)}
+
+            for future in future_to_index:
+                idx = future_to_index[future]  # 获取原始索引
+                results[idx] = future.result()  # 将结果存放到对应位置
+
+        return results
+
+
+# ---------------------------------------------------------------------------------- not used below ----------------------------------------------------------------------------------
 # ** 高维插值函数，插值最后两个维度
 def interp_2d_20241213(target_x, target_y, origin_x, origin_y, data, method="linear"):
     """
@@ -228,8 +295,25 @@ def interp_2d_parallel_20241213(target_x, target_y, origin_x, origin_y, data, me
     return interpolated_data
 
 
+def _test_sum(a,b):
+    return a+b
+
+
 if __name__ == "__main__":
-    import time
+    # 参数列表：每个参数是元组
+    params_list = [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
+
+    # 创建并行执行器
+    executor = ParallelExecutor()
+
+    # 并行运行
+    results = executor.run(_test_sum, params_list)
+
+    # 验证结果顺序
+    print("Params:", params_list)
+    print("Results:", results)
+    pass
+    """ import time
 
     import matplotlib.pyplot as plt
 
@@ -263,4 +347,4 @@ if __name__ == "__main__":
     plt.figure()
     plt.contourf(target_x, target_y, interpolated_data[0, 0, :, :])
     plt.colorbar()
-    plt.show()
+    plt.show() """

oafuncs-0.0.86/oafuncs/oa_draw.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+Author: Liu Kun && 16031215@qq.com
+Date: 2024-09-17 17:26:11
+LastEditors: Liu Kun && 16031215@qq.com
+LastEditTime: 2024-11-21 13:10:47
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\oa_draw.py
+Description:
+EditPlatform: vscode
+ComputerInfo: XPS 15 9510
+SystemInfo: Windows 11
+Python Version: 3.11
+"""
+
+
+import warnings
+
+import cartopy.crs as ccrs
+import cartopy.feature as cfeature
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import numpy as np
+import xarray as xr
+from cartopy.mpl.ticker import LatitudeFormatter, LongitudeFormatter
+
+__all__ = ["fig_minus", "gif", "add_cartopy", "add_gridlines", "MidpointNormalize", "add_lonlat_unit", "contour", "contourf", "quiver"]
+
+warnings.filterwarnings("ignore")
+
+
+def fig_minus(ax_x=None, ax_y=None, cbar=None, decimal=None, add_space=False):
+    """
+    Description: 将坐标轴刻度中的负号替换为减号
+
+    param {*} ax_x : x轴
+    param {*} ax_y : y轴
+    param {*} cbar : colorbar
+    param {*} decimal : 小数位数
+    param {*} add_space : 是否在非负数前面加空格
+
+    return {*} ax_x or ax_y or cbar
+    """
+    if ax_x is not None:
+        current_ticks = ax_x.get_xticks()
+    if ax_y is not None:
+        current_ticks = ax_y.get_yticks()
+    if cbar is not None:
+        current_ticks = cbar.get_ticks()
+    # 先判断是否需要加空格，如果要，先获取需要加的索引
+    if add_space:
+        index = 0
+        for _, tick in enumerate(current_ticks):
+            if tick >= 0:
+                index = _
+                break
+    if decimal is not None:
+        # my_ticks = [(round(float(iii), decimal)) for iii in my_ticks]
+        current_ticks = [f"{val:.{decimal}f}" if val != 0 else "0" for val in current_ticks]
+
+    out_ticks = [f"{val}".replace("-", "\u2212") for val in current_ticks]
+    if add_space:
+        # 在非负数前面加两个空格
+        out_ticks[index:] = ["  " + m for m in out_ticks[index:]]
+
+    if ax_x is not None:
+        ax_x.set_xticklabels(out_ticks)
+        return ax_x
+    if ax_y is not None:
+        ax_y.set_yticklabels(out_ticks)
+        return ax_y
+    if cbar is not None:
+        cbar.set_ticklabels(out_ticks)
+        return cbar
+
+
+# ** 将生成图片/已有图片制作成动图
+def gif(image_list: list, gif_name: str, duration=0.2):  # 制作动图，默认间隔0.2
+    """
+    Description
+        Make gif from images
+    Parameters
+        image_list : list, list of images
+        gif_name : str, name of gif
+        duration : float, duration of each frame
+    Returns
+        None
+    Example
+        gif(["1.png", "2.png"], "test.gif", duration=0.2)
+    """
+    import imageio.v2 as imageio
+
+    frames = []
+    for image_name in image_list:
+        frames.append(imageio.imread(image_name))
+    imageio.mimsave(gif_name, frames, format="GIF", duration=duration)
+    print("Gif制作完成！")
+    return
+
+
+# ** 转化经/纬度刻度
+def add_lonlat_unit(lon=None, lat=None, decimal=2):
+    """
+    param        {*} lon : 经度列表
+    param        {*} lat : 纬度列表
+    param        {*} decimal : 小数位数
+    return       {*} 转化后的经/纬度列表
+    example     : add_lonlat_unit(lon=lon, lat=lat, decimal=2)
+    """
+
+    def _format_longitude(x_list):
+        out_list = []
+        for x in x_list:
+            if x > 180:
+                x -= 360
+            # degrees = int(abs(x))
+            degrees = round(abs(x), decimal)
+            direction = "E" if x >= 0 else "W"
+            out_list.append(f"{degrees:.{decimal}f}°{direction}" if x != 0 and x != 180 else f"{degrees}°")
+        return out_list if len(out_list) > 1 else out_list[0]
+
+    def _format_latitude(y_list):
+        out_list = []
+        for y in y_list:
+            if y > 90:
+                y -= 180
+            # degrees = int(abs(y))
+            degrees = round(abs(y), decimal)
+            direction = "N" if y >= 0 else "S"
+            out_list.append(f"{degrees:.{decimal}f}°{direction}" if y != 0 else f"{degrees}°")
+        return out_list if len(out_list) > 1 else out_list[0]
+
+    if lon and lat:
+        return _format_longitude(lon), _format_latitude(lat)
+    elif lon:
+        return _format_longitude(lon)
+    elif lat:
+        return _format_latitude(lat)
+
+
+# ** 添加网格线
+def add_gridlines(ax, projection=ccrs.PlateCarree(), color="k", alpha=0.5, linestyle="--", linewidth=0.5):
+    # add gridlines
+    gl = ax.gridlines(crs=projection, draw_labels=True, linewidth=linewidth, color=color, alpha=alpha, linestyle=linestyle)
+    gl.right_labels = False
+    gl.top_labels = False
+    gl.xformatter = LongitudeFormatter(zero_direction_label=False)
+    gl.yformatter = LatitudeFormatter()
+
+    return ax, gl
+
+
+# ** 添加地图
+def add_cartopy(ax, lon=None, lat=None, projection=ccrs.PlateCarree(), gridlines=True, landcolor="lightgrey", oceancolor="lightblue", cartopy_linewidth=0.5):
+    # add coastlines
+    ax.add_feature(cfeature.LAND, facecolor=landcolor)
+    ax.add_feature(cfeature.OCEAN, facecolor=oceancolor)
+    ax.add_feature(cfeature.COASTLINE, linewidth=cartopy_linewidth)
+    # ax.add_feature(cfeature.BORDERS, linewidth=cartopy_linewidth, linestyle=":")
+
+    # add gridlines
+    if gridlines:
+        ax, gl = add_gridlines(ax, projection)
+
+    # set longitude and latitude format
+    lon_formatter = LongitudeFormatter(zero_direction_label=False)
+    lat_formatter = LatitudeFormatter()
+    ax.xaxis.set_major_formatter(lon_formatter)
+    ax.yaxis.set_major_formatter(lat_formatter)
+
+    # set extent
+    if lon is not None and lat is not None:
+        lon_min, lon_max = lon.min(), lon.max()
+        lat_min, lat_max = lat.min(), lat.max()
+        ax.set_extent([lon_min, lon_max, lat_min, lat_max], crs=projection)
+
+
+# ** 自定义归一化类，使得0值处为中心点
+class MidpointNormalize(mpl.colors.Normalize):
+    """
+    Description: 自定义归一化类，使得0值处为中心点
+
+    param {*} mpl.colors.Normalize : 继承Normalize类
+    return {*}
+
+    Example:
+    nrom = MidpointNormalize(vmin=-2, vmax=1, vcenter=0)
+    """
+
+    def __init__(self, vmin=None, vmax=None, vcenter=None, clip=False):
+        self.vcenter = vcenter
+        super().__init__(vmin, vmax, clip)
+
+    def __call__(self, value, clip=None):
+        x, y = [self.vmin, self.vcenter, self.vmax], [0, 0.5, 1.0]
+        return np.ma.masked_array(np.interp(value, x, y, left=-np.inf, right=np.inf))
+
+    def inverse(self, value):
+        y, x = [self.vmin, self.vcenter, self.vmax], [0, 0.5, 1]
+        return np.interp(value, x, y, left=-np.inf, right=np.inf)
+
+
+# -----------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+# ** 绘制填色图
+def contourf(data,x=None,y=None,cmap='coolwarm',show=True,store=None,cartopy=False):
+    """
+    Description: 绘制填色图
+
+    param {*} data : 二维数据
+    param {*} x : x轴坐标
+    param {*} y : y轴坐标
+    param {*} cmap : 颜色映射
+    param {*} show : 是否显示
+    param {*} store : 是否保存
+    param {*} cartopy : 是否使用cartopy
+
+    return {*}
+    """
+    data = np.array(data)
+    if x is None or y is None:
+        x = np.arange(data.shape[1])
+        y = np.arange(data.shape[0])
+    if cartopy:
+        fig, ax = plt.subplots(subplot_kw={'projection': ccrs.PlateCarree()})
+        add_cartopy(ax, lon=x, lat=y)
+        ax.contourf(x, y, data, transform=ccrs.PlateCarree(), cmap=cmap)
+    else:
+        plt.contourf(x, y, data, cmap=cmap)
+    plt.colorbar()
+    plt.savefig(store, dpi=600, bbox_inches="tight") if store else plt.show()
+    plt.close()
+
+
+# ** 绘制等值线图
+def contour(data, x=None, y=None, cmap="coolwarm", show=True, store=None, cartopy=False):
+    """
+    Description: 绘制等值线图
+
+    param {*} data : 二维数据
+    param {*} x : x轴坐标
+    param {*} y : y轴坐标
+    param {*} cmap : 颜色映射
+    param {*} show : 是否显示
+    param {*} store : 是否保存
+    param {*} cartopy : 是否使用cartopy
+
+    return {*}
+    """
+    data = np.array(data)
+    if x is None or y is None:
+        x = np.arange(data.shape[1])
+        y = np.arange(data.shape[0])
+    if cartopy:
+        fig, ax = plt.subplots(subplot_kw={"projection": ccrs.PlateCarree()})
+        add_cartopy(ax, lon=x, lat=y)
+        cr = ax.contour(x, y, data, transform=ccrs.PlateCarree(), cmap=cmap)
+    else:
+        cr = plt.contour(x, y, data, cmap=cmap)
+    plt.clabel(cr, inline=True, fontsize=10)
+    plt.savefig(store, dpi=600, bbox_inches="tight") if store else plt.show()
+    plt.close()
+
+
+# ** 绘制矢量场
+def quiver(u, v, lon, lat, picname=None, cmap="coolwarm", scale=0.25, width=0.002, x_space=5, y_space=5):
+    """
+    param        {*} u : 二维数据
+    param        {*} v : 二维数据
+    param        {*} lon : 经度, 1D or 2D
+    param        {*} lat : 纬度, 1D or 2D
+    param        {*} picname : 图片保存的文件名(含路径)
+    param        {*} cmap : 颜色映射，默认coolwarm
+    param        {*} scale : 箭头的大小 / 缩小程度
+    param        {*} width : 箭头的宽度
+    param        {*} x_space : x轴间隔
+    param        {*} y_space : y轴间隔
+    return       {*} 无返回值
+    """
+    # 创建新的网格位置变量(lat_c, lon_c)
+    if len(lon.shape) == 1 and len(lat.shape) == 1:
+        lon_c, lat_c = np.meshgrid(lon, lat)
+    else:
+        lon_c, lat_c = lon, lat
+
+    # 设置箭头的比例、颜色、宽度等参数
+    # scale = 0.25  # 箭头的大小 / 缩小程度
+    # color = '#E5D1FA'
+    # width = 0.002  # 箭头的宽度
+    # x_space = 1
+    # y_space = 1
+
+    # 计算矢量的大小
+    S = xr.DataArray(np.hypot(np.array(u), np.array(v)))
+
+    mean_S = S.nanmean()
+
+    # 使用 plt.quiver 函数绘制矢量图
+    # 通过设置 quiver 函数的 pivot 参数来指定箭头的位置
+    quiver_plot = plt.quiver(
+        lon_c[::y_space, ::x_space],
+        lat_c[::y_space, ::x_space],
+        u[::y_space, ::x_space],
+        v[::y_space, ::x_space],
+        S[::y_space, ::x_space],  # 矢量的大小，可以不要
+        pivot="middle",
+        scale=scale,
+        #  color=color, # 矢量的颜色，单色
+        cmap=cmap,  # 矢量的颜色，多色
+        width=width,
+    )
+    # plt.quiverkey(quiver_plot, X=0.90, Y=0.975, U=1, label='1 m/s', labelpos='E', fontproperties={'size': 10})
+    plt.quiverkey(quiver_plot, X=0.87, Y=0.975, U=mean_S, label=f"{mean_S:.2f} m/s", labelpos="E", fontproperties={"size": 10})
+    plt.colorbar(quiver_plot)
+    plt.xlabel("X")
+    plt.ylabel("Y")
+
+    plt.savefig(picname, bbox_inches="tight") if picname is not None else plt.show()
+    plt.clf()
+    plt.close()
+
+
+
+if __name__ == "__main__":
+    pass