如何在 Python 中执行双线性插值
Posted
技术标签:
【中文标题】如何在 Python 中执行双线性插值【英文标题】：How to perform bilinear interpolation in Python 【发布时间】：2012-01-29 11:57:27 【问题描述】：我想使用 python 执行双线性插值。 我要为其插入高度的示例 gps 点是：
B = 54.4786674627
L = 17.0470721369
使用已知坐标和高度值的四个相邻点：
n = [(54.5, 17.041667, 31.993), (54.5, 17.083333, 31.911), (54.458333, 17.041667, 31.945), (54.458333, 17.083333, 31.866)]
z01 z11
z
z00 z10
import math
z00 = n[0][2]
z01 = n[1][2]
z10 = n[2][2]
z11 = n[3][2]
c = 0.016667 #grid spacing
x0 = 56 #latitude of origin of grid
y0 = 13 #longitude of origin of grid
i = math.floor((L-y0)/c)
j = math.floor((B-x0)/c)
t = (B - x0)/c - j
z0 = (1-t)*z00 + t*z10
z1 = (1-t)*z01 + t*z11
s = (L-y0)/c - i
z = (1-s)*z0 + s*z1
z01 z0 z11
z
z00 z1 z10
2022 年编辑： 我要感谢所有在这个问题发布十多年后给出新答案的人。
【问题讨论】：
你有四舍五入的错误，你正在四舍五入？？？如果删除floor 会发生什么？
什么是 L 和 B？您要插值的点的坐标？
@machine 渴望没错
请注意 - 纬度和经度不是平面坐标，因此如果您处理较大的距离，此结果将无法满足您的需求。
【参考方案1】：
这是一个您可以使用的可重用函数。它包括文档测试和数据验证：
def bilinear_interpolation(x, y, points):
'''Interpolate (x,y) from values associated with four points.
The four points are a list of four triplets: (x, y, value).
The four points can be in any order. They should form a rectangle.
>>> bilinear_interpolation(12, 5.5,
... [(10, 4, 100),
... (20, 4, 200),
... (10, 6, 150),
... (20, 6, 300)])
165.0
'''
# See formula at: http://en.wikipedia.org/wiki/Bilinear_interpolation
points = sorted(points) # order points by x, then by y
(x1, y1, q11), (_x1, y2, q12), (x2, _y1, q21), (_x2, _y2, q22) = points
if x1 != _x1 or x2 != _x2 or y1 != _y1 or y2 != _y2:
raise ValueError('points do not form a rectangle')
if not x1 <= x <= x2 or not y1 <= y <= y2:
raise ValueError('(x, y) not within the rectangle')
return (q11 * (x2 - x) * (y2 - y) +
q21 * (x - x1) * (y2 - y) +
q12 * (x2 - x) * (y - y1) +
q22 * (x - x1) * (y - y1)
) / ((x2 - x1) * (y2 - y1) + 0.0)
您可以通过添加运行测试代码：
if __name__ == '__main__':
import doctest
doctest.testmod()
在您的数据集上运行插值会产生：
>>> n = [(54.5, 17.041667, 31.993),
(54.5, 17.083333, 31.911),
(54.458333, 17.041667, 31.945),
(54.458333, 17.083333, 31.866),
]
>>> bilinear_interpolation(54.4786674627, 17.0470721369, n)
31.95798688313631
【讨论】：
@Raymond Hettinger 非常感谢您的回答。为什么scipy.interpolate.interp2d 在这种情况下不起作用？ interp2d 不也是双线性插值，因为它“在二维网格上插值”（来源：docs.scipy.org/doc/scipy-0.14.0/reference/generated/...）？
@DavidC。 AFAIK，当您使用kind=linear 时，它是双线性插值。根据经验，我还比较了这个答案和interp2d 和kind=linear 之间的结果——它们完全一样。【参考方案2】：
不确定这是否有很大帮助，但我在使用 scipy 进行线性插值时得到了不同的值：
>>> import numpy as np
>>> from scipy.interpolate import griddata
>>> n = np.array([(54.5, 17.041667, 31.993),
(54.5, 17.083333, 31.911),
(54.458333, 17.041667, 31.945),
(54.458333, 17.083333, 31.866)])
>>> griddata(n[:,0:2], n[:,2], [(54.4786674627, 17.0470721369)], method='linear')
array([ 31.95817681])
【讨论】：
griddata 在单纯形（三角形）中线性插值，而不是在矩形中双线性插值；这意味着它首先进行三角测量（Delaunay？）。【参考方案3】：
受here的启发，我想出了以下sn-p。该 API 针对多次重复使用同一张表进行了优化：
from bisect import bisect_left
class BilinearInterpolation(object):
""" Bilinear interpolation. """
def __init__(self, x_index, y_index, values):
self.x_index = x_index
self.y_index = y_index
self.values = values
def __call__(self, x, y):
# local lookups
x_index, y_index, values = self.x_index, self.y_index, self.values
i = bisect_left(x_index, x) - 1
j = bisect_left(y_index, y) - 1
x1, x2 = x_index[i:i + 2]
y1, y2 = y_index[j:j + 2]
z11, z12 = values[j][i:i + 2]
z21, z22 = values[j + 1][i:i + 2]
return (z11 * (x2 - x) * (y2 - y) +
z21 * (x - x1) * (y2 - y) +
z12 * (x2 - x) * (y - y1) +
z22 * (x - x1) * (y - y1)) / ((x2 - x1) * (y2 - y1))
你可以这样使用它：
table = BilinearInterpolation(
x_index=(54.458333, 54.5),
y_index=(17.041667, 17.083333),
values=((31.945, 31.866), (31.993, 31.911))
)
print(table(54.4786674627, 17.0470721369))
# 31.957986883136307
这个版本没有错误检查，如果你尝试在索引的边界（或超出）使用它会遇到麻烦。有关完整版本的代码，包括错误检查和可选外推，请查看 here。
【讨论】：
【参考方案4】：您也可以参考interp function in matplotlib。
【讨论】：
【参考方案5】：基于此公式的 numpy 实现：
def bilinear_interpolation(x,y,x_,y_,val):
a = 1 /((x_[1] - x_[0]) * (y_[1] - y_[0]))
xx = np.array([[x_[1]-x],[x-x_[0]]],dtype='float32')
f = np.array(val).reshape(2,2)
yy = np.array([[y_[1]-y],[y-y_[0]]],dtype='float32')
b = np.matmul(f,yy)
return a * np.matmul(xx.T, b)
输入：
这里，x_ 是[x0,x1] 的列表，y_ 是[y0,y1] 的列表
bilinear_interpolation(x=54.4786674627,
y=17.0470721369,
x_=[54.458333,54.5],
y_=[17.041667,17.083333],
val=[31.993,31.911,31.945,31.866])
输出：
array([[31.95912739]])
【讨论】：
【参考方案6】：我认为执行floor 函数的意义在于，通常您希望插入一个坐标位于两个离散坐标之间的值。但是，您似乎已经有了最近点的实际坐标值，这使得数学变得简单。
z00 = n[0][2]
z01 = n[1][2]
z10 = n[2][2]
z11 = n[3][2]
# Let's assume L is your x-coordinate and B is the Y-coordinate
dx = n[2][0] - n[0][0] # The x-gap between your sample points
dy = n[1][1] - n[0][1] # The Y-gap between your sample points
dx1 = (L - n[0][0]) / dx # How close is your point to the left?
dx2 = 1 - dx1 # How close is your point to the right?
dy1 = (B - n[0][1]) / dy # How close is your point to the bottom?
dy2 = 1 - dy1 # How close is your point to the top?
left = (z00 * dy1) + (z01 * dy2) # First interpolate along the y-axis
right = (z10 * dy1) + (z11 * dy2)
z = (left * dx1) + (right * dx2) # Then along the x-axis
在翻译您的示例时可能存在一些错误的逻辑，但其要点是您可以根据每个点与插值目标点的距离比其他邻居更近来加权每个点。
【讨论】：
你是不是忘了将left、right和z分别除以dy1+dy2、dy1+dy2和dx1+dx2？
我不知道你为什么要这么做。 dx1、dx2、dy1 和 dy2 都归一化为 0 和 1 之间的补充值（所以 dy1+dy2 总是等于 1），因为 dx 是左邻居和右邻居之间的总距离，对于 dy 也是如此。
@machine 向往我不确定是否清楚目标是根据相邻点 31.993、31.911、31.945、31.866 的高度插入大约 31 米的给定点的高度值。
@machine 向往 感谢您的回答。
@daikini：哈哈，是的，这就是我想要的。我的意思是，通过双线性插值，您可以沿一个轴对两对点进行线性插值，并在两个结果点之间沿另一轴进行线性插值。我认为将所有内容标准化为 [0, 1] 比尝试重新量化离散间隔更有意义。【参考方案7】：
这与定义 here 的解决方案相同，但应用于某些功能并与 Scipy 中可用的 interp2d 进行比较。我们使用 numba 库使插值函数比 Scipy 实现更快。
import numpy as np
from scipy.interpolate import interp2d
import matplotlib.pyplot as plt
from numba import jit, prange
@jit(nopython=True, fastmath=True, nogil=True, cache=True, parallel=True)
def bilinear_interpolation(x_in, y_in, f_in, x_out, y_out):
f_out = np.zeros((y_out.size, x_out.size))
for i in prange(f_out.shape[1]):
idx = np.searchsorted(x_in, x_out[i])
x1 = x_in[idx-1]
x2 = x_in[idx]
x = x_out[i]
for j in prange(f_out.shape[0]):
idy = np.searchsorted(y_in, y_out[j])
y1 = y_in[idy-1]
y2 = y_in[idy]
y = y_out[j]
f11 = f_in[idy-1, idx-1]
f21 = f_in[idy-1, idx]
f12 = f_in[idy, idx-1]
f22 = f_in[idy, idx]
f_out[j, i] = ((f11 * (x2 - x) * (y2 - y) +
f21 * (x - x1) * (y2 - y) +
f12 * (x2 - x) * (y - y1) +
f22 * (x - x1) * (y - y1)) /
((x2 - x1) * (y2 - y1)))
return f_out
我们制作了一个相当大的插值数组来评估每种方法的性能。
示例函数是，
x = np.linspace(0, 4, 13)
y = np.array([0, 2, 3, 3.5, 3.75, 3.875, 3.9375, 4])
X, Y = np.meshgrid(x, y)
Z = np.sin(np.pi*X/2) * np.exp(Y/2)
x2 = np.linspace(0, 4, 1000)
y2 = np.linspace(0, 4, 1000)
Z2 = bilinear_interpolation(x, y, Z, x2, y2)
fun = interp2d(x, y, Z, kind='linear')
Z3 = fun(x2, y2)
fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(10, 6))
ax[0].pcolormesh(X, Y, Z, shading='auto')
ax[0].set_title("Original function")
X2, Y2 = np.meshgrid(x2, y2)
ax[1].pcolormesh(X2, Y2, Z2, shading='auto')
ax[1].set_title("bilinear interpolation")
ax[2].pcolormesh(X2, Y2, Z3, shading='auto')
ax[2].set_title("Scipy bilinear function")
plt.show()
性能测试
没有 numba 库的 Python
bilinear_interpolation函数，在这种情况下，与numba版本相同，只是我们在for循环中将prange更改为python普通range，并删除函数装饰器jit
%timeit bilinear_interpolation(x, y, Z, x2, y2)
每个循环提供 7.15 秒 ± 107 毫秒（7 次运行的平均值 ± 标准偏差，每次 1 个循环）
Python 与 numba numba
%timeit bilinear_interpolation(x, y, Z, x2, y2)
每个循环提供 2.65 毫秒 ± 70.5 微秒（7 次运行的平均值 ± 标准偏差，每次 100 次循环）
Scipy 实现
%%timeit
f = interp2d(x, y, Z, kind='linear')
Z2 = f(x2, y2)
每个循环提供 6.63 ms ± 145 µs（平均值 ± 标准偏差，7 次运行，每次 100 个循环）
在“Intel(R) Core(TM) i7-8700K CPU @ 3.70GHz”上执行性能测试
【讨论】：
可以修改它以处理缺失的 (NaN) 值吗？ 是的，它可以@Nirmal，但需要更多的努力scipy.interpolate.griddata 完美地完成了这项工作，但 Numba 不支持它。【参考方案8】：
我建议以下解决方案：
def bilinear_interpolation(x, y, z01, z11, z00, z10):
def linear_interpolation(x, z0, z1):
return z0 * x + z1 * (1 - x)
return linear_interpolation(y, linear_interpolation(x, z01, z11),
linear_interpolation(x, z00, z10))
【讨论】：
以上是关于如何在 Python 中执行双线性插值的主要内容，如果未能解决你的问题，请参考以下文章