Problem mit 2D-interpolation in SciPy, nicht-rechteckiges-raster

Hinzugefügt 27Aug: Kyle folgte dieser bis auf eine
scipy-user-thread.

30Aug: @Kyle, es sieht aus, als ob da eine Verwechslung zwischen Cartesion X -, Y-und polar Xnew,Ynew.
Siehe "polar" in die viel zu lange Hinweise unten.

# griddata vs SmoothBivariateSpline
# http://stackoverflow.com/questions/3526514/
#   problem-with-2d-interpolation-in-scipy-non-rectangular-grid

# http://www.scipy.org/Cookbook/Matplotlib/Gridding_irregularly_spaced_data
# http://en.wikipedia.org/wiki/Natural_neighbor
# http://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html

from __future__ import division
import sys
import numpy as np
from scipy.interpolate import SmoothBivariateSpline  # $scipy/interpolate/fitpack2.py
from matplotlib.mlab import griddata

__date__ = "2010-10-08 Oct"  # plot diffs, ypow
    # "2010-09-13 Sep"  # smooth relative

def avminmax( X ):
    absx = np.abs( X[ - np.isnan(X) ])
    av = np.mean(absx)
    m, M = np.nanmin(X), np.nanmax(X)
    histo = np.histogram( X, bins=5, range=(m,M) ) [0]
    return "av %.2g  min %.2g  max %.2g  histo %s" % (av, m, M, histo)

def cosr( x, y ):
    return 10 * np.cos( np.hypot(x,y) / np.sqrt(2) * 2*np.pi * cycle )

def cosx( x, y ):
    return 10 * np.cos( x * 2*np.pi * cycle )

def dipole( x, y ):
    r = .1 + np.hypot( x, y )
    t = np.arctan2( y, x )
    return np.cos(t) / r**3

#...............................................................................
testfunc = cosx
Nx = Ny = 20  # interpolate random Nx x Ny points -> Newx x Newy grid
Newx = Newy = 100
cycle = 3
noise = 0
ypow = 2  # denser => smaller error
imclip = (-5., 5.)  # plot trierr, splineerr to same scale
kx = ky = 3
smooth = .01  # Spline s = smooth * z2sum, see note
    # s is a target for sum (Z() - spline())**2  ~ Ndata and Z**2;
    # smooth is relative, s absolute
    # s too small => interpolate/fitpack2.py:580: UserWarning: ier=988, junk out
    # grr error message once only per ipython session
seed = 1
plot = 0

exec "\n".join( sys.argv[1:] )  # run this.py N= ...
np.random.seed(seed)
np.set_printoptions( 1, threshold=100, suppress=True )  # .1f

print 80 * "-"
print "%s  Nx %d Ny %d -> Newx %d Newy %d  cycle %.2g noise %.2g  kx %d ky %d smooth %s" % (
    testfunc.__name__, Nx, Ny, Newx, Newy, cycle, noise, kx, ky, smooth)

#...............................................................................

    # interpolate X Y Z to xnew x ynew --
X, Y = np.random.uniform( size=(Nx*Ny, 2) ) .T
Y **= ypow
    # 1d xlin ylin -> 2d X Y Z, Ny x Nx --
    # xlin = np.linspace( 0, 1, Nx )
    # ylin = np.linspace( 0, 1, Ny )
    # X, Y = np.meshgrid( xlin, ylin )
Z = testfunc( X, Y )  # Ny x Nx
if noise:
    Z += np.random.normal( 0, noise, Z.shape )
# print "Z:\n", Z
z2sum = np.sum( Z**2 )

xnew = np.linspace( 0, 1, Newx )
ynew = np.linspace( 0, 1, Newy )
Zexact = testfunc( *np.meshgrid( xnew, ynew ))
if imclip is None:
    imclip = np.min(Zexact), np.max(Zexact)
xflat, yflat, zflat = X.flatten(), Y.flatten(), Z.flatten()

#...............................................................................
print "SmoothBivariateSpline:"
fit = SmoothBivariateSpline( xflat, yflat, zflat, kx=kx, ky=ky, s = smooth * z2sum )
Zspline = fit( xnew, ynew ) .T  # .T ??

splineerr = Zspline - Zexact
print "Zspline - Z:", avminmax(splineerr)
print "Zspline:    ", avminmax(Zspline)
print "Z:          ", avminmax(Zexact)
res = fit.get_residual()
print "residual %.0f  res/z2sum %.2g" % (res, res / z2sum)
# print "knots:", fit.get_knots()
# print "Zspline:", Zspline.shape, "\n", Zspline
print ""

#...............................................................................
print "griddata:"
Ztri = griddata( xflat, yflat, zflat, xnew, ynew )
        # 1d x y z -> 2d Ztri on meshgrid(xnew,ynew)

nmask = np.ma.count_masked(Ztri)
if nmask > 0:
    print "info: griddata: %d of %d points are masked, not interpolated" % (
        nmask, Ztri.size)
    Ztri = Ztri.data  # Nans outside convex hull
trierr = Ztri - Zexact
print "Ztri - Z:", avminmax(trierr)
print "Ztri:    ", avminmax(Ztri)
print "Z:       ", avminmax(Zexact)
print ""

#...............................................................................
if plot:
    import pylab as pl
    nplot = 2
    fig = pl.figure( figsize=(10, 10/nplot + .5) )
    pl.suptitle( "Interpolation error: griddata - %s, BivariateSpline - %s" % (
        testfunc.__name__, testfunc.__name__ ), fontsize=11 )

    def subplot( z, jplot, label ):
        ax = pl.subplot( 1, nplot, jplot )
        im = pl.imshow(
            np.clip( z, *imclip ),  # plot to same scale
            cmap=pl.cm.RdYlBu,
            interpolation="nearest" )
                # nearest: squares, else imshow interpolates too
                # todo: centre the pixels
        ny, nx = z.shape
        pl.scatter( X*nx, Y*ny, edgecolor="y", s=1 )  # for random XY
        pl.xlabel(label)
        return [ax, im]

    subplot( trierr, 1,
        "griddata, Delaunay triangulation + Natural neighbor: max %.2g" %
        np.nanmax(np.abs(trierr)) )

    ax, im = subplot( splineerr, 2,
        "SmoothBivariateSpline kx %d ky %d smooth %.3g: max %.2g" % (
        kx, ky, smooth, np.nanmax(np.abs(splineerr)) ))

    pl.subplots_adjust( .02, .01, .92, .98, .05, .05 )  # l b r t
    cax = pl.axes([.95, .05, .02, .9])  # l b w h
    pl.colorbar( im, cax=cax )  # -1.5 .. 9 ??
    if plot >= 2:
        pl.savefig( "tmp.png" )
    pl.show() 

Hinweise auf 2d-interpolation, BivariateSpline vs. griddata.

scipy.interpolate.*BivariateSpline und matplotlib.mlab.griddata
beide nehmen 1d-arrays als Argumente:

Znew = griddata( X,Y,Z, Xnew,Ynew )
    # 1d X Y Z Xnew Ynew -> interpolated 2d Znew on meshgrid(Xnew,Ynew)
assert X.ndim == Y.ndim == Z.ndim == 1  and  len(X) == len(Y) == len(Z)

Den Eingängen X,Y,Z beschreiben eine Oberfläche oder eine Wolke von Punkten im 3-Raum:
X,Y (oder Breite,Länge oder ...) Punkte in einer Ebene,
und Z eine Oberfläche oder Gelände über.
X,Y füllen können, die meisten von dem Rechteck [Xmin .. Xmax] x [Ymin .. Ymax],
oder vielleicht nur ein squiggly S oder Y drin.
Die Z Oberfläche kann glatt oder glatt + ein bisschen Lärm,
oder gar nicht glatt, raue vulkanische Berge.

Xnew und Ynew sind in der Regel auch 1d, beschreibt ein rechteckiges raster
der |Xnew| x |Ynew| Punkte, wo Sie wollen, zu interpolieren oder Schätzung Z.

Znew = griddata(...) gibt ein 2d-array über das Netz, np.meshgrid(Xnew,Ynew):

Znew[Xnew0,Ynew0], Znew[Xnew1,Ynew0], Znew[Xnew2,Ynew0] ...
Znew[Xnew0,Ynew1] ...
Znew[Xnew0,Ynew2] ...
...

Xnew,Ynew Punkte weit ab von der Eingabe X,Y s Zauber Probleme.
griddata prüft:

Einem maskierten array zurückgegeben wird, wenn alle Gitterpunkte die außerhalb konvex
Rumpf definiert durch Eingabe der Daten (keine extrapolation durchgeführt werden).

("Konvexe Hülle" wird das Gebiet innerhalb eines imaginären
Gummiband gedehnt, um die ganze X,Y-Punkte.)

griddata funktioniert so, dass zunächst die Konstruktion einer Delaunay-triangulation
der Eingang X -, Y -, dann tun
Natürlicher Nachbar
interpolation. Dieser ist robust und ziemlich schnell.

BivariateSpline, obwohl, kann extrapolieren,
Generierung von wilden Schaukeln ohne Warnung.
Darüber hinaus werden alle *Spline-Routinen in Fitpack
sind sehr empfindlich auf parameter Glättung S.
Dierckx ' s Buch (die Bücher.google-isbn 019853440X p. 89) sagt, dass:

wenn S zu klein ist, die spline-approximation zu Verwackeln
und nimmt zu viel Lärm (overfit);

wenn S zu groß ist der spline zu glatt
und signal verloren (underfit).

Interpolation gestreuter Daten ist schwer, Glättung nicht leicht, beides zusammen wirklich schwer.
Was sollte ein interpolator tun mit großen Löcher in XY, oder sehr laute Z ?
("Wenn Sie wollen, um es zu verkaufen, sind Sie gehen zu müssen, um es zu beschreiben.")

Noch weitere Hinweise, kleingedrucktes:

1d vs 2d: Einige interpolatoren X,Y,Z entweder 1d oder 2d.
Andere nehmen 1d nur, so flatten vor der Interpolation:

Xmesh, Ymesh = np.meshgrid( np.linspace(0,1,Nx), np.linspace(0,1,Ny) )
Z = f( Xmesh, Ymesh )  # Nx x Ny
Znew = griddata( Xmesh.flatten(), Ymesh.flatten(), Z.flatten(), Xnew, Ynew )

Auf maskierte arrays: matplotlib behandelt Sie gut,
Plotten nur entlarvt /non-NaN Punkte.
Aber ich würde nicht Wetten, dass ein bozo-numpy/scipy Funktionen überhaupt funktionieren.
Überprüfen Sie für die interpolation außerhalb der konvexen Hülle von X,Y so:

Znew = griddata(...)
nmask = np.ma.count_masked(Znew)
if nmask > 0:
    print "info: griddata: %d of %d points are masked, not interpolated" % (
        nmask, Znew.size)
    # Znew = Znew.data  # array with NaNs

Auf Polarkoordinaten:
X -, Y-und Xnew,Ynew, sollte sich im selben Raum,
beide Cartesion, oder beide in [rmin .. rmax] x [tmin .. tmax].

Zum plot (r, theta, z) Punkte in 3d:

from mpl_toolkits.mplot3d import Axes3D
Znew = griddata( R,T,Z, Rnew,Tnew )
ax = Axes3D(fig)
ax.plot_surface( Rnew * np.cos(Tnew), Rnew * np.sin(Tnew), Znew )

Siehe auch (habe nicht versucht dies):

ax = subplot(1,1,1, projection="polar", aspect=1.)
ax.pcolormesh(theta, r, Z)

Zwei Tipps für die vorsichtigen Programmierer:

check für Ausreißer, oder lustige Skalierung:

def minavmax( X ):
    m = np.nanmin(X)
    M = np.nanmax(X)
    av = np.mean( X[ - np.isnan(X) ])  # masked ?
    histo = np.histogram( X, bins=5, range=(m,M) ) [0]
    return "min %.2g  av %.2g  max %.2g  histo %s" % (m, av, M, histo)

for nm, x in zip( "X Y Z  Xnew Ynew Znew".split(),
                (X,Y,Z, Xnew,Ynew,Znew) ):
    print nm, minavmax(x)

check-interpolation mit einfachen Daten:

interpolate( X,Y,Z, X,Y )  -- interpolate at the same points
interpolate( X,Y, np.ones(len(X)), Xnew,Ynew )  -- constant 1 ?