Scipy - data interpolation from one irregular grid to another irregular spaced grid

I am struggling with the interpolation between two grids, and I couldn't find an appropriate solution for my problem.

I have 2 different 2D grids, of which the node points are开发者_开发技巧 defined by their X and Y coordinates. The grid itself is not rectangular, but forms more or less a parallelogram (so the X-coordinate for (i,j) is not the same as (i,j+1), and the Y coordinate of (i,j) is different from the Y coordinate of (i+1,j). Both grids have a 37*5 shape and they overlap almost entirely.

For the first grid I have for each point the X-coordinate, the Y-coordinate and a pressure value. Now I would like to interpolate this pressure distribution of the first grid on the second grid (of which also X and Y are known for each point.

I tried different interpolation methods, but my end result was never correct due to the irregular distribution of my grid points. Functions as interp2d or griddata require as input a 1D array, but if I do this, the interpolated solution is wrong (even if I interpolate the pressure values from the original grid again on the original grid, the new pressure values are miles away from the original values.

For 1D interpolation on different irregular grids I use:

def interpolate(X, Y, xNew):
    if xNew<X[0]:
        print 'Interp Warning :', xNew,'is under the interval [',X[0],',',X[-1],']'
        yNew = Y[0]
    elif  xNew>X[-1]:
        print 'Interp Warning :', xNew,'is above the interval [',X[0],',',X[-1],']'
        yNew = Y[-1]
    elif xNew == X[-1] : yNew = Y[-1]
    else:
        ind = numpy.argmax(numpy.bitwise_and(X[:-1]<=xNew,X[1:]>xNew))
        yNew = Y[ind] + ((xNew-X[ind])/(X[ind+1]-X[ind]))*(Y[ind+1]-Y[ind])

    return yNew

but for 2D I thought griddata would be easier to use. Does anyone have experience with an interpolation where my input is a 2D array for the mesh and for the data?

Have another look at interp2d. http://docs.scipy.org/scipy/docs/scipy.interpolate.interpolate.interp2d/#scipy-interpolate-interp2d

Note the second example in the 'x,y' section under 'Parameters'. 'x' and 'y' are 1-D in a loose sense but they can be flattened arrays.

Should be something like this:

f = scipy.interpolate.interp2d([0.25, 0.5, 0.27, 0.58], [0.4, 0.8, 0.42,0.83], [3, 4, 5, 6])

znew = f(.25,.4)

print znew
[ 3.]

znew = f(.26,.41)   # midway between (0.25,0.4,3) and (0.27,0.42,5)

print znew
[ 4.01945345]     # Should be 4 - close enough?

I would have thought you could pass flattened 'xnew' and 'ynew' arrays to 'f()' but I couldn't get that to work. The 'f()' function would accept the row, column syntax though, which isn't useful to you. Because of this limitation with 'f()' you will have to evaluate 'znew' as part of a loop - might should look at nditer for that. Make sure also that it does what you want when '(xnew,ynew)' is outside of the '(x,y)' domain.