scatteredInterpolant

Define some sample points and calculate the value of a trigonometric function at those locations. These points are the sample values for the interpolant.

t = linspace(3/4*pi,2*pi,50)';
x = [3*cos(t); 2*cos(t); 0.7*cos(t)];
y = [3*sin(t); 2*sin(t); 0.7*sin(t)];
v = repelem([-0.5; 1.5; 2],length(t));

Create the interpolant.

F = scatteredInterpolant(x,y,v);

Evaluate the interpolant at query locations (xq,yq).

tq = linspace(3/4*pi+0.2,2*pi-0.2,40)';
xq = [2.8*cos(tq); 1.7*cos(tq); cos(tq)];
yq = [2.8*sin(tq); 1.7*sin(tq); sin(tq)];
vq = F(xq,yq);

Plot the result.

plot3(x,y,v,'.',xq,yq,vq,'.'), grid on
title('Linear Interpolation')
xlabel('x'), ylabel('y'), zlabel('Values')
legend('Sample data','Interpolated query data','Location','Best')

Create an interpolant for a set of scattered sample points, then evaluate the interpolant at a set of 3-D query points.

Define 200 random points and sample a trigonometric function. These points are the sample values for the interpolant.

rng default;
P = -2.5 + 5*rand([200 3]);
v = sin(P(:,1).^2 + P(:,2).^2 + P(:,3).^2)./(P(:,1).^2+P(:,2).^2+P(:,3).^2);

Create the interpolant.

F = scatteredInterpolant(P,v);

Evaluate the interpolant at query locations (xq,yq,zq).

[xq,yq,zq] = meshgrid(-2:0.25:2);
vq = F(xq,yq,zq);

Plot slices of the result.

xslice = [-.5,1,2]; 
yslice = [0,2]; 
zslice = [-2,0];
slice(xq,yq,zq,vq,xslice,yslice,zslice)

Replace the elements in the Values property when you want to change the values at the sample points. You get immediate results when you evaluate the new interpolant because the original triangulation does not change.

Create 50 random points and sample an exponential function. These points are the sample values for the interpolant.

rng('default')
x = -2.5 + 5*rand([50 1]);
y = -2.5 + 5*rand([50 1]);
v = x.*exp(-x.^2-y.^2);

Create the interpolant.

F = scatteredInterpolant(x,y,v)

F = 
  scatteredInterpolant with properties:

                 Points: [50x2 double]
                 Values: [50x1 double]
                 Method: 'linear'
    ExtrapolationMethod: 'linear'

Evaluate the interpolant at (1.40,1.90).

F(1.40,1.90)

ans = 
0.0069

Change the interpolant sample values and reevaluate the interpolant at the same point.

vnew = x.^2 + y.^2;
F.Values = vnew;
F(1.40,1.90)

ans = 
5.6491

Use groupsummary to eliminate duplicate sample points and control how they are combined prior to calling scatteredInterpolant.

Create a 200-by-3 matrix of sample point locations. Add duplicate points in the last five rows.

P = -2.5 + 5*rand(200,3);
P(197:200,:) = repmat(P(196,:),4,1);

Create a vector of random values at the sample points.

V = rand(size(P,1),1);

If you attempt to use scatteredInterpolant with duplicate sample points, it throws a warning and averages the corresponding values in V to produce a single unique point. However, you can use groupsummary to eliminate the duplicate points prior to creating the interpolant. This is particularly useful if you want to combine the duplicate points using a method other than averaging.

Use groupsummary to eliminate the duplicate sample points and preserve the maximum value in V at the duplicate sample point location. Specify the sample points matrix as the grouping variable and the corresponding values as the data.

[V_unique,P_unique] = groupsummary(V,P,@max);

Since the grouping variable has three columns, groupsummary returns the unique groups P_unique as a cell array. Convert the cell array back into a matrix.

P_unique = [P_unique{:}];

Create the interpolant. Since the sample points are now unique, scatteredInterpolant does not throw a warning.

I = scatteredInterpolant(P_unique,V_unique);

Compare the results of several different interpolation algorithms offered by scatteredInterpolant.

Create a sample data set of 50 scattered points. The number of points is artificially small to highlight the differences between the interpolation methods.

x = -3 + 6*rand(50,1);
y = -3 + 6*rand(50,1);
v = sin(x).^4 .* cos(y);

Create the interpolant and a grid of query points.

F = scatteredInterpolant(x,y,v);
[xq,yq] = meshgrid(-3:0.1:3);

Plot the results using the 'nearest', 'linear', and 'natural' methods. Each time the interpolation method changes, you need to requery the interpolant to get the updated results.

F.Method = 'nearest';
vq1 = F(xq,yq);
plot3(x,y,v,'mo')
hold on
mesh(xq,yq,vq1)
title('Nearest Neighbor')
legend('Sample Points','Interpolated Surface','Location','NorthWest')

F.Method = 'linear';
vq2 = F(xq,yq);
figure
plot3(x,y,v,'mo')
hold on
mesh(xq,yq,vq2)
title('Linear')
legend('Sample Points','Interpolated Surface','Location','NorthWest')

F.Method = 'natural';
vq3 = F(xq,yq);
figure
plot3(x,y,v,'mo')
hold on
mesh(xq,yq,vq3)
title('Natural Neighbor')
legend('Sample Points','Interpolated Surface','Location','NorthWest')

Plot the exact solution.

figure
plot3(x,y,v,'mo')
hold on
mesh(xq,yq,sin(xq).^4 .* cos(yq))
title('Exact Solution')
legend('Sample Points','Exact Surface','Location','NorthWest')

Since R2024a

Compare the results of several different extrapolation methods offered by scatteredInterpolant.

Create a sample data set of 50 scattered points, and calculate the value of a trigonometric function at those locations. These points are the sample values for the interpolant.

rng default
x = -3 + 6*rand(50,1);
y = -3 + 6*rand(50,1);
v = sin(x).^4 .* cos(y);

Create the interpolant.

F = scatteredInterpolant(x,y,v)

F = 
  scatteredInterpolant with properties:

                 Points: [50x2 double]
                 Values: [50x1 double]
                 Method: 'linear'
    ExtrapolationMethod: 'linear'

Compute the boundary of the input data.

C = convhull(x,y);
xc = [x(C); x(C(1))];
yc = [y(C); y(C(1))];
vc = [v(C); v(C(1))];

Evaluate the interpolant at query locations (xq,yq) using linear extrapolation based on boundary gradients. Then, plot the result of the interpolation and extrapolation.

[xq,yq] = meshgrid(-4:0.1:4);
vq1 = F(xq,yq);

surf(xq,yq,vq1,FaceAlpha=0.5,DisplayName="Interpolation + extrapolation result",EdgeColor=[100 100 100]./256,FaceColor="interp")
hold on
plot3(x,y,v,"black.",MarkerSize=20,DisplayName="Sample points")
plot3(xc,yc,vc,"magenta-",LineWidth=3,DisplayName="Interpolation-extrapolation boundary")
title("Linear interpolation + linear extrapolation")
legend(Location="NorthEast")
zlim([-2.8 1.3])
colorbar
colormap jet
clim([-2.8 1.3])
view([-183.69 21.20])
hold off

Modify the interpolant to use nearest neighbor extrapolation, and evaluate and visualize the interpolant.

F.ExtrapolationMethod = "nearest";
vq2 = F(xq,yq);

surf(xq,yq,vq2,FaceAlpha=0.5,DisplayName="Interpolation + extrapolation result",EdgeColor=[100 100 100]./256,FaceColor="interp")
hold on
plot3(x,y,v,"black.",MarkerSize=20,DisplayName="Sample points")
plot3(xc,yc,vc,"magenta-",LineWidth=3,DisplayName="Interpolation-extrapolation boundary")
title("Linear interpolation + Nearest extrapolation")
legend(Location="NorthEast")
zlim([-2.8 1.3])
colorbar
colormap jet
clim([-2.8 1.3])
view([-183.69 21.20])
hold off

Modify the interpolant to extend the interpolation boundary into the extrapolation domain, and evaluate and visualize the interpolant.

F.ExtrapolationMethod = "boundary";
vq3 = F(xq,yq);

surf(xq,yq,vq3,FaceAlpha=0.5,DisplayName="Interpolation + extrapolation result",EdgeColor=[100 100 100]./256,FaceColor="interp")
hold on
plot3(x,y,v,"black.",MarkerSize=20,DisplayName="Sample points")
plot3(xc,yc,vc,"magenta-",LineWidth=3,DisplayName="Interpolation-extrapolation boundary")
title("Linear interpolation + Boundary extrapolation")
legend(Location="NorthEast")
zlim([-2.8 1.3])
colorbar
colormap jet
clim([-2.8 1.3])
view([-183.69 21.20])
hold off

Compare the extrapolation methods by examining the plotted results. Boundary extrapolation preserves continuity between the interpolation and extrapolation domain, while nearest neighbor extrapolation can be discontinuous along the boundary. Boundary extrapolation does not produce extreme values in the extrapolation domain, while linear extrapolation can produce extreme values.

Since R2023b

Interpolate multiple data sets at the same query points.

Create a sample data set with 50 scattered points represented by sample point vectors x and y.

rng("default")
x = -3 + 6*rand(50,1);
y = -3 + 6*rand(50,1);

To interpolate multiple data sets, create a matrix where each column represents the values of a different function at the sample points.

s1 = sin(x).^4 .* cos(y);
s2 = sin(x) + cos(y);
s3 = x + y;
s4 = x.^2 + y;
v = [s1 s2 s3 s4];

Create query point vectors, which indicate the locations to perform interpolation for each set of values in v.

xq = -3:0.1:3;
yq = -3:0.1:3;

Create the interpolant F.

F = scatteredInterpolant(x,y,v)

F = 
  scatteredInterpolant with properties:

                 Points: [50x2 double]
                 Values: [50x4 double]
                 Method: 'linear'
    ExtrapolationMethod: 'linear'

Evaluate the interpolant at the query locations. Each page of Vq contains the interpolated values for the corresponding data set in v.

Vq = F({xq,yq});
size(Vq)

ans = 1×3

    61    61     4

Plot the interpolated values for each data set.

tiledlayout(2,2)
nexttile
plot3(x,y,v(:,1),'mo')
hold on
mesh(xq,yq,Vq(:,:,1)')
title("sin(x).^4 .* cos(y)")

nexttile
plot3(x,y,v(:,2),'mo')
hold on
mesh(xq,yq,Vq(:,:,2)')
title("sin(x) + cos(y)")

nexttile
plot3(x,y,v(:,3),'mo')
hold on
mesh(xq,yq,Vq(:,:,3)')
title("x + y")

nexttile
plot3(x,y,v(:,4),'mo')
hold on
mesh(xq,yq,Vq(:,:,4)')
title("x.^2 + y")

lg = legend("Sample Points","Interpolated Surface");
lg.Layout.Tile = "north";