# [SciPy-User] weighted griddata

Charles R Harris charlesr.harris@gmail....
Thu Sep 16 17:53:54 CDT 2010

```On Thu, Sep 16, 2010 at 2:27 PM, Pauli Virtanen <pav@iki.fi> wrote:

> Thu, 16 Sep 2010 10:20:14 -0700, Adam Ryan wrote:
> [clip]
> > I was wondering if there is a way to use scipy.interpolate.griddata with
> > weights.
>
> You are probably looking for routines for data smoothing, and not for
> interpolation. griddata only computes interpolants, functions f(x) that
> go through all the data points
>
>        f(x_i) = y_i
>
> If you want some data points to have more weight than others, then
> probably you don't want to this condition to hold (otherwise you get
> sharp peaks around points with low weights).
>
> Data smoothing is a different problem than interpolation, and the
> algorithms in griddata cannot do it, and they are not easily modified to
> do it either.
>
> > Specifically, I have a list of lines.  Each line represents the position
> > of a wave on a beach at a timestamp, and is comprised of a list of
> > mostly connected points.  I can use griddata and all the points of all
> > the lines to create an interpolation of the position of the wave vs
> > time.  The problem is that the lines are the result of image processing
> > and the points vary in confidence level.
>
> So you have data
>
>        (x[i], y[i], t[i])
>
> and you'd like to fit a 2-D surface to it? I guess you used griddata to
> find the graph of the function y = f(x, t)?
>
> > Currently I'm just tossing out
> > points that don't pass muster, but I'd like a more robust solution,
> > something like a weighted griddata, or some other method.  Any advice
> > would be great.
>
> Since your data is 2-D, you can in principle use the spline routines in
> scipy.interpolate for data smoothing. For example,
>
>        ip = interpolate.SmoothBivariateSpline(x=x, y=t, z=y,
>                w=weights)
>        xi, ti = mgrid[0:1:70j,0:1:80j]
>        yi = ip.ev(xi.ravel(), ti.ravel()).reshape(xi.shape)
>
> instead of
>
>        yi = griddata((x, t), y, (xi, ti))
>
> You may need to fiddle with the smoothing parameter `s=...` for
> SmoothBivariateSpline.
>
> Ok, a word of warning: personally, I've found that these 2-D spline
> routines often produce garbage, especially when `s` is small, and you can
> waste a lot of time fiddling with them. These routines come from the
> ancient FITPACK library (http://www.netlib.org/dierckx/), and I suppose
> it's not fully refined in this respect...
>
> Or, you can maybe fit a 1-D spline (UnivariateSpline) at each `t`
> separately, and use the smoothed results in griddata. The 1D spline
> routines are robust.
>
>
I've found the automatic 1D spline fits to also produce garbage.  However,
they work OK with user supplied knots.

> Another option that you can try is to cook up some inverse distance
> weighting scheme -- you can use scipy.spatial.cKDTree/KDTree to do the
> fast N nearest neighbour lookups. Scipy doesn't have an implementation
> for these algorithms at the moment, so you'd have to do it from scratch.
>
> Maybe other people have more ideas?
>
>
I think the rbf routines might be appropriate.

Chuck
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://mail.scipy.org/pipermail/scipy-user/attachments/20100916/169851d4/attachment.html
```

More information about the SciPy-User mailing list