在Python中以给定坐标将2D数据重新放置到较大的2D网格上

Question

I have a square 2D array data that I would like to add to a larger 2D array frame at some given set of non-integer coordinates coords . The idea is that data will be interpolated onto frame with it's center at the new coordinates.

Some toy data:

# A gaussian to add to the frame
x, y = np.meshgrid(np.linspace(-1,1,10), np.linspace(-1,1,10))
data = 50*np.exp(-np.sqrt(x**2+y**2)**2)

# The frame to add the gaussian to
frame = np.random.normal(size=(100,50))

# The desired (x,y) location of the gaussian center on the new frame
coords = 23.4, 22.6

Here's the idea. I want to add this:

to this:

to get this:

If the coordinates were integers (indexes), of course I could simply add them like this:

frame[23:33,22:32] += data

But I want to be able to specify non-integer coordinates so that data is regridded and added to frame .

I've looked into PIL.Image methods but my use case is just for 2D data, not images. Is there a way to do this with just scipy ? Can this be done with interp2d or a similar function? Any guidance would be greatly appreciated!

Answer 1

Scipy's shift function from scipy.ndimage.interpolation is what you are looking for, as long as the grid spacings between data and frame overlap. If not, look to the other answer. The shift function can take floating point numbers as input and will do a spline interpolation. First, I put the data into an array as large as frame, then shift it, and then add it. Make sure to reverse the coordinate list, as x is the rightmost dimension in numpy arrays. One of the nice features of shift is that it sets to zero those values that go out of bounds.

import numpy as np
import matplotlib.pyplot as plt
from scipy.ndimage.interpolation import shift

# A gaussian to add to the frame.
x, y = np.meshgrid(np.linspace(-1,1,10), np.linspace(-1,1,10))
data = 50*np.exp(-np.sqrt(x**2+y**2)**2)

# The frame to add the gaussian to
frame = np.random.normal(size=(100,50))
x_frame = np.arange(50)
y_frame = np.arange(100)

# The desired (x,y) location of the gaussian center on the new frame.
coords = np.array([23.4, 22.6])

# First, create a frame as large as the frame.
data_large = np.zeros(frame.shape)
data_large[:data.shape[0], :data.shape[1]] = data[:,:]

# Subtract half the distance as the bottom left is at 0,0 instead of the center.
# The shift of 4.5 is because data is 10 points wide.
# Reverse the coords array as x is the last coordinate.
coords_shift = -4.5
data_large = shift(data_large, coords[::-1] + coords_shift)

frame += data_large

# Plot the result and add lines to indicate to coordinates
plt.figure()
plt.pcolormesh(x_frame, y_frame, frame, cmap=plt.cm.jet)
plt.axhline(coords[1], color='w')
plt.axvline(coords[0], color='w')
plt.colorbar()
plt.gca().invert_yaxis()
plt.show()

The script gives you the following figure, which has the desired coordinates indicated with white dotted lines.

Answer 2

One possible solution is to use scipy.interpolate.RectBivariateSpline . In the code below, x_0 and y_0 are the coordinates of a feature from data (ie, the position of the center of the Gaussian in your example) that need to be mapped to the coordinates given by coords . There are a couple of advantages to this approach:

1. If you need to "place" the same object into multiple locations in the output frame , the spline needs to be computed only once (but evaluated multiple times).

2. In case you actually need to compute integrated flux of the model over a pixel, you can use the integral method of scipy.interpolate.RectBivariateSpline .

Resample using spline interpolation:

from scipy.interpolate import RectBivariateSpline
x = np.arange(data.shape[1], dtype=np.float)
y = np.arange(data.shape[0], dtype=np.float)
kx = 3; ky = 3; # spline degree
spline = RectBivariateSpline(
    x, y, data.T, kx=kx, ky=ky, s=0
)

# Define coordinates of a feature in the data array.
# This can be the center of the Gaussian:
x_0 = (data.shape[1] - 1.0) / 2.0
y_0 = (data.shape[0] - 1.0) / 2.0

# create output grid, shifted as necessary:
yg, xg = np.indices(frame.shape, dtype=np.float64)
xg += x_0 - coords[0] # see below how to account for pixel scale change
yg += y_0 - coords[1] # see below how to account for pixel scale change

# resample and fill extrapolated points with 0:
resampled_data = spline.ev(xg, yg)
extrapol = (((xg < -0.5) | (xg >= data.shape[1] - 0.5)) |
            ((yg < -0.5) | (yg >= data.shape[0] - 0.5)))
resampled_data[extrapol] = 0

Now plot the frame and resampled data :

plt.figure(figsize=(14, 14));
plt.imshow(frame+resampled_data, cmap=plt.cm.jet,
          origin='upper', interpolation='none', aspect='equal')
plt.show()

If you also want to allow for scale changes, then replace code for computing xg and yg above with:

coords = 20, 80 # change coords to easily identifiable (in plot) values
zoom_x = 2 # example scale change along X axis
zoom_y = 3 # example scale change along Y axis
yg, xg = np.indices(frame.shape, dtype=np.float64)
xg = (xg - coords[0]) / zoom_x + x_0
yg = (yg - coords[1]) / zoom_y + y_0

Most likely this is what you actually want based on your example. Specifically, the coordinates of pixels in data are "spaced" by 0.222(2) distance units. Therefore it actually seems that for your particular example (whether accidental or intentional), you have a zoom factor of 0.222(2). In that case your data image would shrink to almost 2 pixels in the output frame.

---

Comparison to @Chiel answer

In the image below, I compare the results from my method (left), @Chiel 's method (center) and difference (right panel):

Fundamentally, the two methods are quite similar and possibly even use the same algorithm (I did not look at the code for shift but based on the description - it also uses splines). From comparison image it is visible that the biggest differences are at the edges and, for unknown to me reasons, shift seems to truncate the shifted image slightly too soon.

I think the biggest difference is that my method allows for pixel scale changes and it also allows re-use of the same interpolator to place the original image at different locations in the output frame. @Chiel 's method is somewhat simpler but (what I did not like about it is that) it requires creation of a larger array ( data_large ) into which the original image is placed in the corner.

Answer 3

While the other answers have gone into detail, but here's my lazy solution:

xc,yc = 23.4, 22.6
x, y = np.meshgrid(np.linspace(-1,1,10)-xc%1, np.linspace(-1,1,10)-yc%1)
data = 50*np.exp(-np.sqrt(x**2+y**2)**2)
frame = np.random.normal(size=(100,50))
frame[23:33,22:32] += data

And it's the way you liked it. As you mentioned, the coordinates of both are the same, so the origin of data is somewhere between the indices. Now just simply shift it by the amount you want it to be off a grid point (remainder to one) in the second line and you're good to go (you might need to flip the sign, but I think this is correct).