将Matplotlib streamplot坐标转换为NumPy坐标：实现散度点周围动态距离渐变着色

I get it—your original approach of using rectangles to mark divergence points and then parsing the plot as an array is way too clunky and slow. Let’s ditch that and use a far more efficient, flexible method that works directly with your coordinate grid instead of post-processing the plot image.

The core idea is to compute a distance field across your entire coordinate grid, convert that field into a gradient color map, and then overlay your streamplot on top of this gradient background. No image array conversions, no hacky marker hunting—just clean, fast numeric operations.

Step-by-Step Implementation #

Here’s a complete, customizable example using your coordinate setup and a sample divergence point at (0,0):

import numpy as np
import matplotlib.pyplot as plt

# 1. Set up your coordinate grid (matches your original setup)
xs = np.linspace(-10, 10, 2000)
ys = np.linspace(-10, 10, 2000)
X, Y = np.meshgrid(xs, ys)

# 2. Define your vector field (replace this with your actual field)
# Example: A simple radial divergence field from (0,0)
U = X
V = Y

# 3. Calculate the distance field from your divergence point
divergence_point = (0, 0)
distance = np.sqrt((X - divergence_point[0])**2 + (Y - divergence_point[1])**2)

# 4. Create your gradient map (customize this to tweak the fade effect)
# We'll use a Gaussian decay for smooth, natural-looking fading
scale = 2  # Adjust this to make the gradient wider/narrower
gradient = np.exp(-distance / scale)  # Higher values = closer to the point

# 5. Plot everything
fig, ax = plt.subplots(figsize=(8, 8))

# Draw the gradient background first
ax.imshow(
    gradient,
    extent=[xs.min(), xs.max(), ys.min(), ys.max()],
    origin='lower',  # Matches our meshgrid's coordinate system
    cmap='viridis',  # Swap this for any colormap (e.g., 'plasma', 'magma')
    alpha=0.6  # Adjust transparency so streamlines stay visible
)

# Overlay the streamplot
ax.streamplot(
    X, Y, U, V,
    color='black',
    linewidth=0.5,
    density=1.5  # Tweak density to control how many streamlines are drawn
)

# Final formatting
ax.set_xlim(xs.min(), xs.max())
ax.set_ylim(ys.min(), ys.max())
ax.set_aspect('equal')  # Keep the plot square to avoid distortion

plt.show()

Key Advantages & Customization Tips #

• Speed: NumPy’s vectorized operations compute the 2000x2000 distance field in milliseconds—no waiting for plot-to-array conversions.
• Flexibility:
  • To change the divergence point, just update the divergence_point tuple.
  • For multiple divergence points, compute individual distance fields and combine them (e.g., gradient = np.exp(-distance1/scale) + np.exp(-distance2/scale)).
  • Adjust the fade curve: Replace np.exp(-distance/scale) with other functions like 1/(1 + distance) for a different decay shape.
  • Swap the colormap: Use any Matplotlib colormap, or even create a custom one with LinearSegmentedColormap.
• No Hacky Workarounds: This avoids the need for patches (like circles or rectangles) that limit dynamic adjustments—everything is controlled through numeric parameters.

内容的提问来源于stack exchange，提问作者Yoav Tarazy