oafuncs 0.0.97.1__py3-none-any.whl

oafuncs/__init__.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+Author: Liu Kun && 16031215@qq.com
+Date: 2024-09-17 16:09:20
+LastEditors: Liu Kun && 16031215@qq.com
+LastEditTime: 2025-03-09 16:28:01
+FilePath: \\Python\\My_Funcs\\OAFuncs\\oafuncs\\__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 *
+
+# ------------------- 2024-12-13 12:31:06 -------------------
+# 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_sign/
+from .oa_sign import *
+
+# ------------------- 2024-12-13 12:31:06 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/oa_tool/
+from .oa_tool import *
+# ------------------- 2025-03-09 16:28:01 -------------------
+# path: My_Funcs/OAFuncs/oafuncs/_script/
+from ._script import *
+# ------------------- 2025-03-16 15:56:01 -------------------

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/_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/oa_cmap.py

@@ -0,0 +1,215 @@
+#!/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('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"]),
+        "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"), 
+        # "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}")
+            print(f"Unknown cmap name: {cmap_name}\nNow return 'rainbow' as default.")
+            return mpl.colormaps.get_cmap("rainbow")
+
+
+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)