Got it, let’s break down how to solve this problem—creating a colorblind-friendly wind field plot with custom arrow styles for specific data ranges in Python. Here are practical, actionable approaches tailored to your NetCDF data and requirements:

The simplest way to apply custom arrow styles to specific data ranges is to split your dataset into subsets (based on speed, u/v components, or any criteria you want) and plot each subset separately with unique styling parameters. This works seamlessly with both plt.quiver and plt.barbs.

Step-by-Step Example Code #

First, load your NetCDF data and prepare your grid:

import numpy as np
import matplotlib.pyplot as plt
import xarray as xr  # Use xarray for easy NetCDF handling

# Load your data (replace with your file path)
ds = xr.open_dataset("your_wind_data.nc")
lon, lat = ds.lon.values, ds.lat.values
u, v = ds.u.values, ds.v.values
lon_grid, lat_grid = np.meshgrid(lon, lat)

# Calculate wind speed (or use u/v components directly for filtering)
wind_speed = np.sqrt(u**2 + v**2)

Next, define your data ranges and plot each subset with custom styles:

# Define masks for different speed ranges
low_speed_mask = wind_speed < 5
medium_speed_mask = (wind_speed >= 5) & (wind_speed < 15)
high_speed_mask = wind_speed >= 15

# Use a colorblind-friendly colormap (viridis is built-in and tested)
cmap = plt.cm.viridis
norm = plt.Normalize(wind_speed.min(), wind_speed.max())

# Create the plot
plt.figure(figsize=(12, 8))

# Plot low-speed arrows: thin, small heads
plt.quiver(
    lon_grid[low_speed_mask], lat_grid[low_speed_mask],
    u[low_speed_mask], v[low_speed_mask],
    color=cmap(norm(wind_speed[low_speed_mask])),
    width=0.001, headwidth=2, headlength=3, linewidths=0.5
)

# Plot medium-speed arrows: moderate size
plt.quiver(
    lon_grid[medium_speed_mask], lat_grid[medium_speed_mask],
    u[medium_speed_mask], v[medium_speed_mask],
    color=cmap(norm(wind_speed[medium_speed_mask])),
    width=0.002, headwidth=3, headlength=4, linewidths=0.8
)

# Plot high-speed arrows: thick, large heads to stand out
high_quiver = plt.quiver(
    lon_grid[high_speed_mask], lat_grid[high_speed_mask],
    u[high_speed_mask], v[high_speed_mask],
    color=cmap(norm(wind_speed[high_speed_mask])),
    width=0.003, headwidth=4, headlength=5, linewidths=1.2
)

# Add colorbar and labels
plt.colorbar(high_quiver, label="Wind Speed (m/s)")
plt.title("Colorblind-Friendly Wind Field with Custom Arrow Styles")
plt.xlabel("Longitude")
plt.ylabel("Latitude")
plt.show()

For plt.barbs Users #

If you prefer barbs instead of quivers, apply the same batch logic with barb-specific parameters:

plt.figure(figsize=(12, 8))

# Low-speed barbs: short length, small increments
plt.barbs(
    lon_grid[low_speed_mask], lat_grid[low_speed_mask],
    u[low_speed_mask], v[low_speed_mask],
    color=cmap(norm(wind_speed[low_speed_mask])),
    length=4, barb_increments={"half": 2, "full": 4, "flag": 20}
)

# Medium-speed barbs: standard length
plt.barbs(
    lon_grid[medium_speed_mask], lat_grid[medium_speed_mask],
    u[medium_speed_mask], v[medium_speed_mask],
    color=cmap(norm(wind_speed[medium_speed_mask])),
    length=6, barb_increments={"half": 5, "full": 10, "flag": 50}
)

# High-speed barbs: longer length, thicker lines
high_barbs = plt.barbs(
    lon_grid[high_speed_mask], lat_grid[high_speed_mask],
    u[high_speed_mask], v[high_speed_mask],
    color=cmap(norm(wind_speed[high_speed_mask])),
    length=8, barb_increments={"half": 5, "full": 10, "flag": 50},
    linewidth=1.5
)

plt.colorbar(high_barbs, label="Wind Speed (m/s)")
plt.title("Colorblind-Friendly Wind Barbs with Custom Styles")
plt.xlabel("Longitude")
plt.ylabel("Latitude")
plt.show()

If you need fully custom arrow shapes (not just adjusting existing parameters), use matplotlib.patches.FancyArrowPatch to draw individual arrows tailored to your data. This is more code-intensive but gives you full control over arrow geometry.

Quick Example Snippet #

from matplotlib.patches import FancyArrowPatch

plt.figure(figsize=(12, 8))

# Loop through each data point
for x, y, u_comp, v_comp, speed in zip(lon_grid.flat, lat_grid.flat, u.flat, v.flat, wind_speed.flat):
    # Define arrow style based on speed
    if speed < 5:
        arrow_style = "->,head_width=0.1,head_length=0.2"
        line_width = 0.5
    elif speed <15:
        arrow_style = "->,head_width=0.15,head_length=0.3"
        line_width = 0.8
    else:
        arrow_style = "->,head_width=0.2,head_length=0.4"
        line_width = 1.2
    
    # Calculate arrow endpoint
    dx = u_comp * 0.1  # Scale factor to fit your plot
    dy = v_comp * 0.1
    arrow = FancyArrowPatch((x, y), (x+dx, y+dy), 
                            arrowstyle=arrow_style,
                            color=cmap(norm(speed)),
                            linewidth=line_width)
    plt.gca().add_patch(arrow)

plt.xlim(lon.min(), lon.max())
plt.ylim(lat.min(), lat.max())
plt.colorbar(plt.cm.ScalarMappable(norm=norm, cmap=cmap), label="Wind Speed (m/s)")
plt.title("Custom Arrow Wind Field")
plt.show()

• Stick to matplotlib's built-in colorblind-friendly colormaps: viridis, plasma, inferno, and magma are all designed to be easily distinguishable by people with common color vision deficiencies.
• Avoid red-green color schemes entirely—these are the most problematic for red-green colorblind users.
• Add a clear, labeled colorbar to make sure your audience can map colors to data values.

内容的提问来源于stack exchange，提问作者Rajkamal Singh