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