matplotlib稀疏（常规）数据的轮廓显示了人工制品

Question

I would like to contour data that are quite sparse and where a maximum is going diagonally through the picture; the matplotlib contour function invents minima between the sampled maxima.

Starting with the densely sampled case where everything looks as expected:

import matplotlib.pyplot as plt
import matplotlib.tri as tri
import numpy as np

x_1D = np.linspace(0., 10., 100)
y_1D = np.linspace(0., 10., 100)
x, y = np.meshgrid(x_1D, y_1D)
z = np.empty_like(x)
def peak(y, y0):
    return np.exp(-(y-y0)**2)
for i in range(x_1D.size):
    z[:,i] = peak(y_1D, i/x_1D.size*y_1D.max())

fig, ax = plt.subplots(ncols=3)

ax[0].set_title('measured data')
ax[0].scatter(x, y, marker='s', c=z, cmap=plt.cm.jet, s=25)

ax[1].set_title('contour')
ax[1].contourf(x, y, z, levels=14, cmap=plt.cm.jet)

# define grid
xi = np.linspace(x_1D.min()-0.1, x_1D.max()+0.1, 1000)
yi = np.linspace(y_1D.min()-0.1, y_1D.max()+0.1, 1000)

# grid the data
triang = tri.Triangulation(x.flatten(), y.flatten())
interpolator = tri.LinearTriInterpolator(triang, z.flatten())
Xi, Yi = np.meshgrid(xi, yi)
zi = interpolator(Xi, Yi)

ax[2].set_title('interpolated')
ax[2].contourf(xi, yi, zi, levels=14, cmap=plt.cm.jet)

plt.show()

yields

When x is sampled less by a factor 10, ie x_1D = np.linspace(0., 10., 10) , minima appear between the sampled maxima in the contour plot.

Is there a way how to avoid this artefact and make the contour of the sparsely sampled data look like the one of the densely sampled data?

EDIT: Thanks for the answer that works very nicely on the example I provided. Unfortunately, I have simplified the problem too far. Rather than talking about one diagonal line, I should have enquired about an arbitrary number of peaks moving in arbitrary directions through the picture; eg replace the peak-generation by

z = np.zeros_like(x)
def peak(y, y0):
    return np.exp(-(y-y0)**2)
for i in range(x_1D.size):
    z[:,i] += peak(y_1D, np.cos(i/x_1D.size*np.pi)*y_1D.max()*0.05+y_1D.max()*0.8)
for i in range(x_1D.size):
    z[:,i] += peak(y_1D, np.sin(i/x_1D.size*np.pi/2.)*y_1D.max()*0.5)

resulting in

Answer 1

The main issue with your approach is that the triangulation algorithm doesn't know that the peaks should be connecting to eachother between the "x-slices" (your line of dense data points for a constant x).

Simplifying a bit, the triangulation algorithm will look at the neighbours in the x and y direction and connect to those. Then, when trying to interpolate using this triangulation, the points between the peaks will be roughly an average of the nearest points in the x direction and hence the minima will appear. The best solution is to make your own triangulation, with the peaks connected directly.

Fortunately, we can actually hack the triangulation to make it connect to the peaks by shifting the coordinates in the y direction such that the peaks are all aligned horizontally. This works because the triangulation algorithm uses the coordinates that you pass it. In your example this is easy to accomplish because we can just apply the simple shift y_s = y - x . In general you would have to get the equation for your peak (call it y_p(x) ) and then subtract that from y to get the y_s .

Now that you have a shifted triangulation, you can make a new denser grid (like you did) and apply the same shift. Then, you interpolate in the shifted mesh with the shifted dense grid to get the z values correctly interpolated. Finally, you un-shift the dense grid to get the correct y values and plot it.

Below is the code of applying this concept to your code and the final result. As you can see. It works quite well for this case.

import matplotlib.pyplot as plt
import matplotlib.tri as tri
import numpy as np

def peak(y, y0):
    return np.exp(-(y-y0)**2)

x_1D = np.linspace(0., 10., 10)
y_1D = np.linspace(0., 10., 100)
x, y = np.meshgrid(x_1D, y_1D)
z = np.empty_like(x)

for i in range(x_1D.size):
    z[:,i] = peak(y_1D, i/x_1D.size*y_1D.max())

fig, ax = plt.subplots(ncols=4)

ax[0].set_title('measured data')
ax[0].scatter(x, y, marker='s', c=z, cmap=plt.cm.jet, s=25)

ax[1].set_title('contour')
ax[1].contourf(x, y, z, levels=14, cmap=plt.cm.jet)

# define output grid
xi_1D = np.linspace(x_1D.min()-0.1, x_1D.max()+0.1, 1000)
yi_1D = np.linspace(y_1D.min()-0.1, y_1D.max()+0.1, 1000)
xi, yi = np.meshgrid(xi_1D, yi_1D)

# Old Linear Interpolation
triang = tri.Triangulation(x.flatten(), y.flatten())
interpolator = tri.LinearTriInterpolator(triang, z.flatten())
zi = interpolator(xi, yi)

ax[2].set_title('interpolated')
ax[2].contourf(xi, yi, zi, levels=14, cmap=plt.cm.jet)

# === SHIFTED LINEAR INTERPOLATION ===

# make shifted interpolating mesh for the data
y_s=y-x
triang_s = tri.Triangulation(x.flatten(), y_s.flatten())
interpolator_s = tri.LinearTriInterpolator(triang_s, z.flatten())

# interpolate in the shifted state
yi_s = yi-xi
zi_s = interpolator_s(xi, yi_s)

# unshift the fine mesh
yi_us = yi_s+xi

ax[3].set_title('interpolated (shifted)')
ax[3].contourf(xi, yi_us, zi_s, levels=14, cmap=plt.cm.jet)


plt.show()