def test_step_before_stop():
num_points = 5
num_dimensions = 3
known_points = np.random.rand(num_points, num_dimensions)
known_values = np.random.rand(num_points)
interp_ranges = [
[2, 1, 1],
[0, 1, 1],
[0, 1, 1],
]
with pytest.raises(ValueError):
griddata(known_points, known_values, interp_ranges)
def test_zero_length_complex_step():
num_points = 5
num_dimensions = 3
known_points = np.random.rand(num_points, num_dimensions)
known_values = np.random.rand(num_points)
interp_ranges = [
[2, 1, 1],
[0, 1, 1],
[0, 1, 0j],
]
with pytest.raises(ValueError):
griddata(known_points, known_values, interp_ranges)
def test_different_num_points_and_values():
num_points = 5
num_dimensions = 3
known_points = np.random.rand(num_points, num_dimensions)
known_values = np.random.rand(num_points + 1)
interp_ranges = [
[0, 1, 1],
[0, 1, 1],
[0, 1, 1],
]
with pytest.raises(ValueError):
griddata(known_points, known_values, interp_ranges)
def test_invalid_known_points_shape():
num_points = 5
num_dimensions = 3
bad_third_dim = 2
known_points = np.random.rand(num_points, num_dimensions, bad_third_dim)
known_values = np.random.rand(num_points)
interp_ranges = [
[0, 1, 1],
[0, 1, 1],
[0, 1, 1],
]
with pytest.raises(ValueError):
griddata(known_points, known_values, interp_ranges)
def compare_interp_for_func(func, func_as_string, image_name):
coord_max = 60
xmax = coord_max
ymax = coord_max
zmax = coord_max
final_shape = (xmax, ymax, zmax)
num_known_points = 100
known_points = np.round(np.random.rand(num_known_points, 3) * np.min([xmax, ymax, zmax]))
grid_ranges = [
[0, xmax, 1],
[0, ymax, 1],
[0, zmax, 1],
]
grid = np.mgrid[0:xmax:1, 0:ymax:1, 0:zmax:1]
known_values = np.array([func(*point) for point in known_points], dtype=np.float64)
true_values = np.reshape([func(x, y, z) for x, y, z in zip(*grid)], final_shape)
linear_interp = scipy.interpolate.griddata(known_points, known_values, tuple(grid), method='linear')
nn_interp = naturalneighbor.griddata(known_points, known_values, grid_ranges)
nn_interp[np.isnan(linear_interp)] = float('nan')
nn_interp_slice = nn_interp[:, :, 20]
linear_interp_slice = linear_interp[:, :, 20]
true_values_slice = true_values[:, :, 20]
nn_interp_err = np.abs(nn_interp_slice - true_values_slice)
linear_interp_err = np.abs(linear_interp_slice - true_values_slice)
fig = plt.figure(figsize=(16, 10))
ax1 = fig.add_subplot(2, 3, 1)
ax1.imshow(true_values_slice)
ax1.set_title("True Values\n{}".format(func_as_string))
ax2 = fig.add_subplot(2, 3, 2)
ax2.imshow(nn_interp_err)
nn_error_str = error_str(nn_interp_err)
ax2.set_title("Natural Neighbor Abs Error\n{}".format(nn_error_str))
ax3 = fig.add_subplot(2, 3, 3)
ax3.imshow(linear_interp_err)
linear_error_str = error_str(linear_interp_err)
ax3.set_title("Linear Barycentric Abs Error\n{}".format(linear_error_str))
ax5 = fig.add_subplot(2, 3, 5)
ax5.imshow(nn_interp_slice)
ax5.set_title("Natural Neighbor Values")
ax6 = fig.add_subplot(2, 3, 6)
ax6.imshow(linear_interp_slice)
ax6.set_title("Linear Barycentric Values")
plt.savefig(image_name, dpi=100)
def test_output_shape():
num_points = 5
num_dimensions = 3
known_points = np.random.rand(num_points, num_dimensions)
known_values = np.random.rand(num_points)
interp_ranges = [
[0, 2, 1],
[0, 1.5, 0.5],
[0, 1, 2],
]
interp_values = griddata(known_points, known_values, interp_ranges)
assert interp_values.shape == (2, 3, 1)
def test_output_size_matches_scipy(grid_ranges):
points = np.random.rand(10, 3)
values = np.random.rand(10)
mesh_grids = tuple(
np.mgrid[grid_ranges[0][0]:grid_ranges[0][1]:grid_ranges[0][2],
grid_ranges[1][0]:grid_ranges[1][1]:grid_ranges[1][2],
grid_ranges[2][0]:grid_ranges[2][1]:grid_ranges[2][2], ])
scipy_result = scipy.interpolate.griddata(points, values, mesh_grids)
nn_result = naturalneighbor.griddata(points, values, grid_ranges)
assert scipy_result.shape == nn_result.shape
def prepare(self, xmin, xmax, ymin, ymax, step):
self._xmin = xmin
self._ymin = ymin
# self._xmax = xmax
# self._ymax = ymax
self._step = step
# The natural neighbor interpolation library that we use only works for 3D data,
# so we must add a dummy 3rd dimension to our 2D data.
dummy = np.zeros((self._known_points.shape[0], 1))
points = np.hstack((self._known_points, dummy))
# Interpolate at all positions in a rectangular grid
# (note again the dummy 3rd dimension).
zmin, zmax, zstep = 0, 1, 1
grid = [[xmin, xmax, step], [ymin, ymax, step], [zmin, zmax, zstep]]
nn = naturalneighbor.griddata(
points, self._known_values,
grid) ## CHECKME: does this include the end point?
# Drop dummy 3rd dimension from the result
self._grid = nn[:, :,
0].T # CHECKME: we can probably avoid the transpose if we build the grid differently
print('Reading: ' + filename)
util.readExnode(filename, fields, importNodeData,
totalNumberOfNodes, dependentFieldNumber)
nodeData += importNodeData
specData[timestep] = nodeData[:, 3]
s += 1
print('Saving nodal data to: ' + specGeomDataFile)
# Save nodal data
np.savez_compressed(specGeomDataFile, spec=specData, geom=nodeGeom)
for timestep in range(numberOfTimesteps):
print(' Performing discrete Sibson interpolation, Time (ms): ' +
str(timestep * timeIncrement * outputFrequency))
specData[timestep, specData[timestep] < 0.01] = initFCa
nn_interp[timestep] = naturalneighbor.griddata(nodeGeom,
specData[timestep],
grid_ranges)
# Save interpolated data
np.savez_compressed(interpDataFile, nn_interp=nn_interp)
print('Saving interpolated data to: ' + interpDataFile)
# -------------------------------------
# Convolve image against selected PSF
# -------------------------------------
convolve = True
if convolve:
# download the psf file if needed
print('Checking for PSF file...')
if not os.path.exists(inputsDir + psfFile):
print('Downloading PSF file to directory: ' + inputsDir)
points = np.transpose(np.array((loc_x, loc_y, loc_z)))
# points = np.transpose(np.array((loc_x, loc_y)))
min_x, max_x = (min(raw.locations[:, 1]) - padding, max(raw.locations[:, 1]) + padding)
min_y, max_y = (min(raw.locations[:, 0]) - padding, max(raw.locations[:, 0]) + padding)
grid_x, grid_y = np.meshgrid(np.linspace(min_x, max_x, n_interp),
np.linspace(min_y, max_y, n_interp))
step_size_x = np.ceil((max_x - min_x) / n_interp)
step_size_y = np.ceil((max_y - min_y) / n_interp)
grid_ranges = [[min_x, max_x, step_size_x],
[min_y, max_y, step_size_y],
[0, 1, 1]]
# grid_rho = griddata(points, rho_vals, (grid_x, grid_y), method='linear')
# grid_pha = griddata(points, phase_vals, (grid_x, grid_y), method='linear')
grid_rho = np.squeeze(nn.griddata(points, rho_vals, grid_ranges))
# grid_pha = np.squeeze(nn.griddata(points, phase_vals, grid_ranges))
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111)
# ax.plot(raw.locations[:, 1] / 1000, raw.locations[:, 0] / 1000, 'k.', markersize=1)
plt.plot(loc_x / 1000, loc_y / 1000, 'k.', markersize=1)
im = ax.pcolor(grid_x / 1000, grid_y / 1000, (grid_rho.T), cmap=cmap)
# divider = make_axes_locatable(ax)
# cax = divider.append_axes("right", size="5%", pad=0.05)
# plt.colorbar(im, cax=cax)
# cbaxes = fig.add_axes([0.9, -0.212, 0.05, 1.09])
# cb = plt.colorbar(im)
ax.set_title('Frequency: {:5.5f} Hz, Period: {:5.5f} s'.format(1 / period, period), fontsize=18)
ax.set_xlabel('Easting (km)', fontsize=18)
ax.set_ylabel('Northing (km)', fontsize=18)
ax.set_aspect('equal')
rho2.append(rho[site][ii])
phavals.append(pha[site][ii])
loc.append(data.sites[site].locations['X'])
z_loc.append(dim)
phavals = np.array(phavals)
rho2 = np.array(rho2)
depths2 = np.array(depths2)
bost2 = np.array(bost2)
rhovals = np.log10(rho2)
bostvals = np.log10(bost2)
periods = np.array(periods)
periods = np.log10(periods)
locs = np.array(loc)
points = np.transpose(np.array((locs, periods, z_loc)))
min_x, max_x = (min(loc), max(loc))
min_p, max_p = (min(periods), max(periods))
grid_ranges = [[min_x, max_x, n_interp * 1j], [min_p, max_p, n_interp * 1j],
[0, 1, 1]]
grid_x, grid_y = np.meshgrid(np.linspace(min_x, max_x, n_interp),
np.log10(np.logspace(min_p, max_p, n_interp)))
# grid_vals = griddata(points, phavals, (grid_x, grid_y), method='linear')
grid_vals = np.squeeze(nn.griddata(points, phavals, grid_ranges))
plt.figure()
plt.pcolor(grid_x, grid_y, grid_vals.T, cmap=cmap)
plt.colorbar()
plt.clim([0, 90])
plt.gca().invert_yaxis()
plt.show()
import scipy.interpolate import numpy as np import naturalneighbor num_points = 10 num_dimensions = 3 points = np.random.rand(num_points, num_dimensions) values = np.random.rand(num_points) grids = tuple(np.mgrid[0:100:1, 0:50:100j, 0:100:2]) print(np.mgrid[0:100:1, 0:100:1, 0:1:1][:, 0, 0, 0]) scipy_interpolated_values = scipy.interpolate.griddata(points, values, grids) grid_ranges = [[0, 100, 1], [0, 50, 100j], [0, 100, 2]] nn_interpolated_values = naturalneighbor.griddata(points, values, grid_ranges)
remain_datapoint = xy[5:]
remain_f = f[5:]
iteration = (sample_num - len(cur_datapoint)) // 5
for i in range(0, iteration):
vor = Voronoi(cur_datapoint)
fig = voronoi_plot_2d(vor)
plt.savefig('out/' + '_vor.png')
plt.close()
# sibson interpolate
z = np.zeros((cur_datapoint.shape[0], 1))
xyz = np.concatenate((cur_datapoint, z), axis=1)
grid_ranges = [[0, size[0], 1], [0, size[1], 1], [0, 1, 1]]
nn_interpolated_values = naturalneighbor.griddata(
xyz, cur_f, grid_ranges)[:, :, 0]
imsave('out/' + str(i) + '_sibson_interpolate.png',
nn_interpolated_values)
# get sibson interpolation with remain datapoint
remain_interpolate = []
for j in range(remain_datapoint.shape[0]):
pts = remain_datapoint[j]
remain_interpolate.append(nn_interpolated_values[int(pts[0]),
int(pts[1])])
remain_interpolate = np.array(remain_interpolate)
d = (remain_interpolate - remain_f)**2
rmse = (np.sum(d) / d.shape[0])**0.5