# 3D Interpolation in Python

Zeeshan Afridi Oct 10, 2023

Interpolation is the method of constructing new data points within a defined range of a discrete set. Interpolation means finding value between points or curves.

From a mathematical point of view, interpolation is obtaining the value of specific unknown data points located between other known data points.

## Importance of Interpolation

Interpolation is a powerful tool for making predictions, data analysis, and many other applications. It predicts unknown values for geographical-related data, such as noise level, rainfall, elevation, etc.

Interpolation has many uses. In Machine Learning (ML), we often deal with missing data in a dataset, and interpolation is often used to substitute those values.

## Install SciPy for Interpolation in Python

To use interpolation in Python, we need to use the SciPy core library and, more specifically, the interpolation module.

SciPy provides many valuable functions for mathematical processing and data analysis optimization. It provides useful functions for obtaining one-dimensional, two-dimensional, and three-dimensional interpolation.

We need to know how to install the SciPy library in Python to move forward.

To install SciPy, go to your command line interface and type the following command.

pip install scipy

Once it is successfully installed, we can import it into our Python program using the import keyword.

## Use SciPy’s interpn() Method for 3D Interpolation in Python

We can perform 3D interpolation using the SciPy library’s interpn() method. It means we can find three or higher dimensions with the help of this method.

Syntax of the interpn() function:

scipy.interpolate.interpn(
points, values, xi, method="linear", bounds_error=True, fill_value=nan
)

Parameters of the interpn() function:

1. points: tuple of ndarray of float, having shapes (m1, ),…,(mn, ).

A regular grid in n dimensions is defined through these points. The points in each dimension (i.e., every element of the points tuple) must be strictly ascending or descending.

2. values: array-like, shape (m1,…,mn,…).

The data is on the regular grid in n dimensions. Complex data can be acceptable.

3. xi : ndarray of shape (…,ndim).

This is where the coordinates for sampling the gridded data are at.

4. method: str, optional

The methods of interpolation are linear, nearest, and splinef2d. splinef2d is only supported for 2D data.

5. bounds_error: bool, optional

If it is true, when interpolated values are requested from outside of the domain of the input data, a ValueError is raised. If it is false, then fill_value is used.
6. fill_value: number, optional

If we provide a number, the function can use points outside the interpolation domain; if None, the values outside the domain are extrapolated. Extrapolation is not supported by the method splinef2d.

The interpn() method returns values_x: ndarray, shape xi.shape[:-1] + values.shape[ndim:]. The interpolated values.ndarray is a multidimensional container where the shape length of each dimension and ndim is the number of dimensions.

Now we have understood the interpn() function and its parameters. Let’s give a practical example of it.

In this example, we pass three arguments to the interpn() method.

Example Code:

# import libraries
from scipy.interpolate import interpn
import numpy as np

# define a function to get the value

def v_function_3d(x, y, z):
return 3 * x + 4 * y - z

# the np.linspace() function returns the interval between the given numbers.
x = np.linspace(0, 4, 5)
y = np.linspace(0, 5, 6)
z = np.linspace(0, 6, 7)

# in three dimensions, a point's coordinates are treated collectively as a single object.
points = (x, y, z)

# meshgrid, it changes NumPy arrays into coordinate matrices or grids of values
values = v_function_3d(*np.meshgrid(*points, indexing="ij"))

# coordinates to sample the gridded data are
point = np.array([2.21, 3.12, 1.15])

# evaluate the 3d interpolating function at a point
print(interpn(points, values, point))

Output:

[17.96]

## Use RegularGridInterpolator for 3D Interpolation in Python

Interpolation on a regular or rectilinear grid in any number of dimensions is performed using the class RegularGridInterpolator.

A rectilinear grid, or a rectangular grid with regular or uneven spacing, is required to define the data. It supports linear, nearest-neighbor, and spline interpolations.

We can choose an interpolation method after setting up the interpolator object.

We use RegularGridInterpolator when we linearly interpolate the surrounding grid points to interpolate. Input data in regularly spaced.

The following example explains how to use RegularGridInterpolator for interpolation.

# import libraries
import scipy.interpolate as reg_grid
import numpy as np

# define a function to get value

def v_function_3d(x, y, z):
return 2 * x + 3 * y - z

# define an interpolating function
RGI = reg_grid.RegularGridInterpolator

# arrays constituting the 3d grid
x = np.linspace(0, 50, 50)
y = np.linspace(0, 50, 50)
z = np.linspace(0, 50, 50)

# in three dimensions, a point is a number (coordinates) that are treated collectively as a single object.
points = (x, y, z)

# meshgrid, it changes NumPy arrays into coordinate matrices or grids of values
vals = v_function_3d(*np.meshgrid(*points, indexing="ij"))

# make the interpolator
rgi = RGI(points, values=vals)
pnt = (2.5, 3.5, 1.5)
print(rgi(pnt))

Output:

13.999999999999998

## Conclusion

We can use 3D interpolation in Python with the help of the scipy library and its method interpn() or RegularGridInterpolator. We can easily make predictions, data analysis, and many other applications.

Interpolation help users determine what data might exist outside the collected data.

Zeeshan is a detail oriented software engineer that helps companies and individuals make their lives and easier with software solutions.