def rbf(x, u, x_smooth, u_smooth, variant, smooth): u_exp_int = int.Rbf(x, u, function=variant, smooth=smooth) u_smooth_int = int.Rbf(x_smooth, u_smooth, function=variant, smooth=smooth) xx = np.linspace(-200, -70, 1000) u_exp_interpolated = u_exp_int(xx) u_smooth_interpolated = u_smooth_int(xx) return u_exp_interpolated, u_smooth_interpolated, xx
def rbf_interp(fem_coords,exp_coords,data,interp_direc): import scipy.interpolate as sp from code_settings import pipeline_files pf = pipeline_files() interp_method = pf.interp_method if (interp_direc == 0): ref_coords = fem_coords int_coords = exp_coords interpolated_data = np.zeros(int_coords.shape) else: ref_coords = exp_coords int_coords = fem_coords interpolated_data = np.zeros(int_coords.shape) for i in range(ref_coords.shape[0]): rbfi_x = sp.Rbf(ref_coords[i,:,0],ref_coords[i,:,1],ref_coords[i,:,2],data[i,:,0],method = interp_method) rbfi_y = sp.Rbf(ref_coords[i,:,0],ref_coords[i,:,1],ref_coords[i,:,2],data[i,:,1],method = interp_method) rbfi_z = sp.Rbf(ref_coords[i,:,0],ref_coords[i,:,1],ref_coords[i,:,2],data[i,:,2],method = interp_method) interpolated_data[i,:,0] = rbfi_x(int_coords[i,:,0],int_coords[i,:,1],int_coords[i,:,2]) interpolated_data[i,:,1] = rbfi_y(int_coords[i,:,0],int_coords[i,:,1],int_coords[i,:,2]) interpolated_data[i,:,2] = rbfi_z(int_coords[i,:,0],int_coords[i,:,1],int_coords[i,:,2]) return interpolated_data
def separatrix(points, resolution): points = points[:, np.arctan2(points[1, :], points[0, :]).argsort()] n = 10 ext_points = np.hstack((points[:, -n:], points, points[:, :n])) phi = np.arctan2(ext_points[1, :], ext_points[0, :]) phi[:n] -= 2 * np.pi phi[-n:] += 2 * np.pi sx = scinterp.Rbf(phi, ext_points[0], smooth=200.0) sy = scinterp.Rbf(phi, ext_points[1], smooth=200.0) h = 2 * np.pi / resolution x = np.linspace(-np.pi + h / 2, np.pi + h / 2, resolution) x[x > np.pi] -= 2 * np.pi sep = np.vstack((sx(x), sy(x))).T lengths = np.empty(sep.shape[0]) lengths[0] = 0.0 for i in range(1, sep.shape[0]): lengths[i] = lengths[i - 1] + np.sqrt( np.dot(sep[i - 1] - sep[i], sep[i - 1] - sep[i])) return lengths, sep
def get_tps_displacement(points, transformed_points, width, height): x_dense, y_dense = np.meshgrid(np.arange(0, width), np.arange(0, height)) x = points[:, 0] y = points[:, 1] tx = transformed_points[:, 0] ty = transformed_points[:, 1] u_sparse = x - tx v_sparse = y - ty rbf_u = interpolate.Rbf(tx, ty, u_sparse, smooth=0, epsilon=100, function='thin_plate') rbf_v = interpolate.Rbf(tx, ty, v_sparse, smooth=0, epsilon=100, function='thin_plate') u_dense = np.transpose(rbf_u(x_dense, y_dense)) v_dense = np.transpose(rbf_v(x_dense, y_dense)) return u_dense, v_dense
def interpolate(self, P1, P2): assert len(P1) == len(P2), 'Shapes has different number of points' x = [0] * len(P1) xs = [0] * len(P1) y = [0] * len(P1) ys = [0] * len(P1) for i in xrange(len(P1)): x[i] = P1[i][0] xs[i] = P2[i][0] y[i] = P1[i][1] ys[i] = P2[i][1] def U(r): res = r**2 * np.log(r**2) res[r == 0] = 0 return res SM = 0.1 fx = scipolate.Rbf(x, xs, function=U, smooth=SM) fy = scipolate.Rbf(y, ys, function=U, smooth=SM) cx, cy, E, affcost, L = bookenstain(P1, P2, 15) return fx, fy, E, float(affcost)
def mesh_part(files, axis=[0,1,2], columns=10, rows=10, function='cubic') : ''' Generates a mesh for any part using a similiar process as the wing. /!\ Currently does not fit the panair expectations, work in progress. INPUT : files is a list of several filenames : files 1-2 are the 2 sides (upper/lower, left/right etc.) of the geometry. They will be used to interpolate the points files 3-4 are lines defining the edges (front/back, left/right etc.), they are needed for the boundaries of the wing. axis is a 3-element list defining the order of the axis : the first one is the axis of the columns, the second one is the axis of the rows. columns is the number of points to be created along the column axis rows is the number of points to be created between in every column. Each side of the geometry will have this number of points. function is the type of function to be used in the Rbf interpolation process. Default is 'cubic' but the right one to use really depends on the geometry. OUTPUT : an array of points of shape (c, n, 3), with c being the number of columns, n the number of points in each column, and 3 being the x, y, z coordinates in that order. ''' if len(axis) != 3 : exit('Number of axis incorrect for generation of mesh, must be 3') points_side1 = points_from_stl(files[0]) points_side2 = points_from_stl(files[1]) points_line1 = points_from_stl(files[2]) points_line2 = points_from_stl(files[3]) rbf_side1 = si.Rbf(points_side1[:,axis[0]], points_side1[:,axis[1]], points_side1[:,axis[2]], function=function, smooth=-100) rbf_side2 = si.Rbf(points_side2[:,axis[0]], points_side2[:,axis[1]], points_side2[:,axis[2]], function=function, smooth=-100) rbf_line1 = si.Rbf(points_line1[:,axis[0]], points_line1[:,axis[1]], function='linear') rbf_line2 = si.Rbf(points_line2[:,axis[0]], points_line2[:,axis[1]], function='linear') mesh_all = [] points_columns = np.linspace(min(points_line1[:,axis[0]]), max(points_line1[:,axis[0]]), columns) for c in points_columns : mesh_c = [] line_points = [rbf_line1(c), rbf_line2(c)] points_rows = np.linspace(min(line_points), max(line_points), rows) for r in points_rows : mesh_c.append([c, r, rbf_side1(c, r)]) points_rows = np.linspace(max(line_points), min(line_points), rows) for r in points_rows : mesh_c.append([c, r, rbf_side2(c, r)]) mesh_all.append(mesh_c) return np.array(mesh_all)
def reject_outliers(cross_matched_table, source_uuid): """ To reject matches that don't fit with rbf model :param cross_matched_table: the list of cross matches with the necessary information :param source_uuid: the target source uuid that's been matched :return: an array that represents the relative probability of the target source matching each reference source """ table_copy = copy(cross_matched_table) entry_of_interest = table_copy[np.where( cross_matched_table['tar_uuid'] == source_uuid)] #print('UUID :',source_uuid) #print('conditional :',np.where(cross_matched_table['tar_uuid']==source_uuid)) table_copy.remove_row( np.where(cross_matched_table['tar_uuid'] == source_uuid)[0][0]) matched_offset_ra = entry_of_interest['tar_ra'] - entry_of_interest[ 'ref_ra'] matched_offset_dec = entry_of_interest['tar_dec'] - entry_of_interest[ 'ref_dec'] matched_sep = np.sqrt(matched_offset_ra**2 + matched_offset_dec**2) matched_angle = np.degrees( np.arctan2(matched_offset_dec, matched_offset_ra)) allowed_pos_error = np.sqrt(entry_of_interest['tar_err_ra']**2 + entry_of_interest['tar_err_dec']**2 + entry_of_interest['ref_err_ra']**2 + entry_of_interest['ref_err_dec']**2) d_ra = table_copy['tar_ra'] - table_copy['ref_ra'] d_dec = table_copy['tar_dec'] - table_copy['ref_dec'] model_d_ra = interpolate.Rbf(table_copy['tar_ra'], table_copy['tar_dec'], d_ra, function='linear', smooth=0.032777778) model_d_dec = interpolate.Rbf(table_copy['tar_ra'], table_copy['tar_dec'], d_dec, function='linear', smooth=0.032777778) predicted_offset_ra = model_d_ra(entry_of_interest['tar_ra'], entry_of_interest['tar_dec']) predicted_offset_dec = model_d_dec(entry_of_interest['tar_ra'], entry_of_interest['tar_dec']) predicted_sep = np.sqrt(predicted_offset_ra**2 + predicted_offset_dec**2) predicted_angle = np.degrees( np.arctan2(predicted_offset_dec, predicted_offset_ra)) if np.abs(matched_angle - predicted_angle) > 45. and predicted_sep < matched_sep: return 'reject' elif matched_sep > predicted_sep + allowed_pos_error: return 'reject' else: return 'accept'
def interpolation(noisy, SNR, number_of_pilot, interp): noisy_image = np.zeros((40000, 72, 14, 2)) noisy_image[:, :, :, 0] = np.real(noisy) noisy_image[:, :, :, 1] = np.imag(noisy) if number_of_pilot == 48: idx = [14 * i for i in range(1, 72, 6)] + [4 + 14 * i for i in range(4, 72, 6)] + [7 + 14 * i for i in range(1, 72, 6)] + [ 11 + 14 * i for i in range(4, 72, 6)] elif number_of_pilot == 16: idx = [4 + 14 * i for i in range(1, 72, 9)] + [9 + 14 * i for i in range(4, 72, 9)] elif number_of_pilot == 24: idx = [14 * i for i in range(1, 72, 9)] + [6 + 14 * i for i in range(4, 72, 9)] + [11 + 14 * i for i in range(1, 72, 9)] elif number_of_pilot == 8: idx = [4 + 14 * i for i in range(5, 72, 18)] + [9 + 14 * i for i in range(8, 72, 18)] elif number_of_pilot == 36: idx = [14 * i for i in range(1, 72, 6)] + [6 + 14 * i for i in range(4, 72, 6)] + [11 + 14 * i for i in range(1, 72, 6)] r = [x // 14 for x in idx] c = [x % 14 for x in idx] interp_noisy = np.zeros((40000, 72, 14, 2)) for i in range(len(noisy)): z = [noisy_image[i, j, k, 0] for j, k in zip(r, c)] if (interp == 'rbf'): f = interpolate.Rbf(np.array(r).astype(float), np.array(c).astype(float), z, function='gaussian') X, Y = np.meshgrid(range(72), range(14)) z_intp = f(X, Y) interp_noisy[i, :, :, 0] = z_intp.T elif (interp == 'spline'): tck = interpolate.bisplrep(np.array(r).astype(float), np.array(c).astype(float), z) z_intp = interpolate.bisplev(range(72), range(14), tck) interp_noisy[i, :, :, 0] = z_intp z = [noisy_image[i, j, k, 1] for j, k in zip(r, c)] if (interp == 'rbf'): f = interpolate.Rbf(np.array(r).astype(float), np.array(c).astype(float), z, function='gaussian') X, Y = np.meshgrid(range(72), range(14)) z_intp = f(X, Y) interp_noisy[i, :, :, 1] = z_intp.T elif (interp == 'spline'): tck = interpolate.bisplrep(np.array(r).astype(float), np.array(c).astype(float), z) z_intp = interpolate.bisplev(range(72), range(14), tck) interp_noisy[i, :, :, 1] = z_intp interp_noisy = np.concatenate((interp_noisy[:, :, :, 0], interp_noisy[:, :, :, 1]), axis=0).reshape(80000, 72, 14, 1) return interp_noisy
def diffusercam_svd_xy(stack, rnk, si_mat): print("creating matrix") Ny, Nx = stack[:, :, 0].shape vec = lambda x: x[:].flatten() ymat = np.zeros((Ny*Nx, stack.shape[2])) for j in range(stack.shape[2]): ymat[:, j] = vec(stack[:, :, j]) print("done") print("starting svd") tic = time.time() u, s, vt = svds(ymat, k=rnk) toc = time.time() print("SVD took {}".format(tic - toc)) comps = u.reshape((Ny, Nx, rnk)) weights = np.zeros((stack.shape[2], rnk)) for i in range(stack.shape[2]): for j in range(rnk): weights[i, j] = s[j] * vt[j, i] xq = np.arange( -Nx // 2, Nx // 2) yq = np.arange(-Ny // 2, Ny // 2) Xq, Yq = np.meshgrid(xq, yq) weights_interp = np.zeros((Ny, Nx, rnk)) print("Interpolating") for r in range(rnk): interpolant_r = interpolate.Rbf(si_mat[1, :].T, si_mat[0, :].T, weights[:, r]) weights_interp[:, :, r] = np.rot90(interpolant_r(Xq, Yq), 2) return weights, weights_interp, comps, u, s, vt
def reset(self): """ Reset Gym Env """ self.gp = 0 self.loss_func = 0 self.count = 0 # choose kernel randomly kernel_ind = random.randint(0, len(self.kernels) - 1) kernel = self.kernels[kernel_ind] # Generate function with Gaussian Process self.gp = GaussianProcessRegressor(kernel=kernel) # calculate current prior and interpolate between points z = self.gp.sample_y(self.grid, n_samples=1, random_state=None) #self.loss_func = interpolate.interp2d(self.grid[:,0], self.grid[:,1], z, kind='cubic') #self.loss_func = interpolate.RectBivariateSpline(self.grid[:,0], self.grid[:,1], z) self.loss_func = interpolate.Rbf(self.grid[:, 0], self.grid[:, 1], z) #print("2") # init position and shape self.state = self.hyper_space.sample() # init observation _ need steps to initialize self.step(np.zeros(self.ndim)) f_ = self.gp_eval() # step 0.1 self.step(0.1 * np.ones(self.ndim)) # TODO: RETURN self ons and not self.state ?? # reset counter self.count = 0 return self.obs
def kern_smooth(array_in, x, y, method='linear'): """ read numpy array with nans and return interplated and extrapolated 2d array using Radial Basis Function Interpolation / Kernel Smoothing. Parameters ---------- array_in : read numpy array with nans Returns ------- array_out : return interplated and extrapolated 2d array """ import numpy as np import scipy.interpolate as interpolate xx, yy = np.meshgrid(x, y) vals = ~np.isnan(array_in) f = interpolate.Rbf(xx[vals], yy[vals], array_in[vals]) array_out = f(xx, yy) # plt.imshow(GD1,interpolation='nearest') return (array_out)
def two_d_estimates(values, name, est_function): ''' Get optimal estimator ''' n_bins = 100 binsx = np.linspace(np.min(values[1]), np.max(values[1]), n_bins+1) binsy = np.linspace(np.min(values[2]), np.max(values[2]), n_bins+1) indsx = np.digitize(values[1], binsx) indsy = np.digitize(values[2], binsy) try: est = np.load('theory/{0}_estimates.npy'.format(name)) except IOError: print 'gotta generate the estimator array, grab some coffee...' est = np.zeros((3,n_bins,n_bins)) for i in xrange(n_bins): for j in xrange(n_bins): px = values[0, np.where((indsx==(i+1)) & (indsy==(j+1)))] if px.size == 0: est[0,i,j] = np.nan else: est[0,i,j] = est_function(px) est[1,i,j] = (binsx[i]+binsx[i+1])/2 est[2,i,j] = (binsy[j]+binsy[j+1])/2 np.save('theory/{0}_estimates.npy'.format(name), est) z = est[0].flatten() x = est[1].flatten() y = est[2].flatten() plt.imshow(est[0], extent=[x.min(), x.max(), y.min(), y.max()], interpolation='bilinear', origin='lower', aspect='auto') plt.savefig('theory/estimator_raw_{0}.pdf'.format(name)) plt.clf() mask = np.isnan(z) rbfi = ip.Rbf(x[~mask], y[~mask], z[~mask], function='linear') xx, yy = np.meshgrid(binsx, binsy) zz = rbfi(xx.flatten(), yy.flatten()) plt.imshow(zz.reshape(xx.shape), vmin=0, vmax=1, extent=[binsx.min(), binsx.max(), binsy.min(), binsy.max()], interpolation='bilinear', origin='lower') plt.savefig('theory/estimator_{0}.pdf'.format(name)) plt.clf() ''' Get error from estimator ''' bins = np.linspace(0,1, n_bins+1) inds = np.digitize(values[0], bins) err = [] for i in xrange(n_bins): print i pc1 = values[1, np.where(inds==(i+1))].flatten() pc2 = values[2, np.where(inds==(i+1))].flatten() x_tru = values[0, np.where(inds==(i+1))].flatten() x_std = np.std(rbfi(pc1, pc2) - x_tru) x = (bins[i]+bins[i+1])/2 err.append((x, x_std)) err = np.array(err) plt.plot(err[:,0], err[:,1]) plt.savefig('theory/error_{0}.pdf'.format(name)) plt.clf()
def interp_aod(aod, plume_mask, logging_path, pp): ''' Interpolate using a radial basis function. See models that shows thta this is the best approach. ''' good_mask = aod != -999 # build the interpolation grid y = np.linspace(0, 1, aod.shape[0]) x = np.linspace(0, 1, aod.shape[1]) xx, yy = np.meshgrid(x, y) # create interpolated grid (can extend to various methods) rbf = interpolate.Rbf(xx[good_mask], yy[good_mask], aod[good_mask], function='linear') interpolated_aod = rbf(xx, yy) aod[~good_mask] = interpolated_aod[~good_mask] if pp['plot']: plt.imshow(np.ma.masked_array(aod, ~plume_mask), vmin=0, vmax=2) plt.colorbar() plt.savefig(os.path.join(logging_path, 'combined_aod_interpolated.png')) plt.close() return aod[plume_mask]
def readRama(path): ramas = [] f = open(path, "r") for i in f.readlines(): if i[0] != '#': content = i.strip().split() assert len(content) == 22 ramas.append([float(i) for i in content]) f.close() ramas = np.array(ramas) rama_cons = {} n_dims = 36 * 36 res_names = [ "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y" ] for rama_id, res_name in zip(range(2, 22), res_names): phis = ramas[:, 0] psis = ramas[:, 1] energy = ramas[:, rama_id] rbf = interpolate.Rbf(phis, psis, energy) rama_cons[res_name] = {} rama_cons[res_name]["xi"] = np.array(rbf.xi.T, dtype=np.float64) rama_cons[res_name]["epsilon"] = np.array([rbf.epsilon] * n_dims, dtype=np.float64) rama_cons[res_name]["nodes"] = np.array(rbf.nodes, dtype=np.float64) rama_cons["n_dims"] = n_dims return rama_cons
def __init__(self, obsarr, cosmo_params, invcov, fiducial_model, function='multiquadric', smooth=0.0, weights=[0.2, 0.045, 0.1]): weighted_params = np.array(cosmo_params).copy() norm_mat = np.repeat(np.array([weights]).T, axis=1, repeats=cosmo_params.shape[-1]) weighted_params /= norm_mat self.invcov = invcov self.fid = fiducial_model self.weights = np.array(weights) # print(obsarr.shape) # create a list of Rbf for each independent mode spline_interps = [ interpolate.Rbf(*weighted_params, model, function=function, smooth=smooth) for model in obsarr.T ] # create a function that applies interpolator to the parameters given, for each mode self.interp_func = lambda params: np.array( [ii(*(params / self.weights)) for ii in spline_interps])
def rbf_interp_2d(in_x, in_t, value, uncertainty, out_x, out_t, debug=False): final_sig = [] excluded_inds = np.isnan(value) y = value[~excluded_inds] x = in_x[~excluded_inds] t = in_t[~excluded_inds] err = uncertainty[~excluded_inds] n = 100 inds = np.random.permutation(list(range(len(y)))) y = y[inds[:n]] x = x[inds[:n]] t = t[inds[:n]] def scale(signal, basis): return (signal - min(basis)) / (max(basis) - min(basis)) t_scaled = scale(t, out_t) out_t_scaled = scale(out_t, out_t) x_scaled = scale(x, [0, 1]) #out_x) out_x_scaled = scale(out_x, [0, 1]) #out_x) get_value = interpolate.Rbf(t_scaled, x_scaled, y, function='Gaussian', epsilon=.1) #,metric='seuclidean') import itertools coords = np.array(list(itertools.product(out_t_scaled, out_x_scaled))).T final_sig = get_value(coords[0], coords[1]) final_sig = final_sig.reshape((len(out_t_scaled), len(out_x_scaled))) return final_sig
def load_boat(file='bavaria_match.dat'): """ loads a polar diagram with y axis being TWA, x axis being TWS returns a scipy function object, with following usage: boat_speed = f(TWS, TWA) A TWA > 180 needs to be changed to 360-TWA. the file needs to be like this (default bavaria match): 0 6 8 10 12 14 16 20 52 5.57 6.65 7.15 7.43 7.61 7.72 7.80 1 60 5.97 6.93 7.45 7.73 7.87 7.95 8.03 75 6.34 7.15 7.71 8.01 8.17 8.27 8.41 90 6.36 7.31 7.88 8.08 8.25 8.51 8.79 110 6.23 7.17 7.80 8.16 8.52 8.77 9.10 120 5.84 6.93 7.60 8.03 8.41 8.85 9.44 135 5.03 6.30 7.10 7.69 8.07 8.44 9.33 150 4.19 5.32 6.35 7.07 7.63 8.02 8.76 """ bavaria = np.loadtxt(file) boat_data = bavaria[1:, 1:] x = bavaria[0] # tws y = np.transpose(bavaria)[0] # twa # a, b, first and second are to interpolate to zero a = np.zeros((1, boat_data.shape[1])) b = np.zeros((boat_data.shape[0] + 1, 1)) first = np.concatenate((a, boat_data)) second = np.concatenate((b, first), axis=1) # print(second.shape, x.shape, y.shape) # return interp.interp2d(x, y, second, kind='cubic') mesh = np.meshgrid(x, y) bootf = interp.Rbf(mesh[0], mesh[1], second, function='cubic') return mesh, bootf, second
def generate_deformation_field_rbf(shape, points, max_deform=DEFORMATION_MAX, nb_bound_points=25): """ generate deformation field as thin plate spline deformation in range +/- max_deform :param tuple(int,int) shape: tuple of size 2 :param points: np.array<nb_points, 2> list of landmarks :param float max_deform: maximal deformation distance in any direction :param int nb_bound_points: number of fix boundary points :return: np.array<shape> """ # x_point = points[:, 0] # y_point = points[:, 1] # generate random shifting move = (np.random.random(points.shape[0]) - 0.5) * max_deform # fix boundary points # set the boundary points bound = np.ones(nb_bound_points - 1) x_bound = np.linspace(0, shape[0] - 1, nb_bound_points) y_bound = np.linspace(0, shape[1] - 1, nb_bound_points) x_point = np.hstack((points[:, 0], 0 * bound, x_bound[:-1], (shape[0] - 1) * bound, x_bound[::-1][:-1])) y_point = np.hstack((points[:, 1], y_bound[:-1], (shape[1] - 1) * bound, y_bound[::-1][:-1], 0 * bound)) # the boundary points sex as 0 shift move = np.hstack((move, np.zeros(4 * nb_bound_points - 4))) # create the interpolation function smooth = 0.2 * max_deform rbf = interpolate.Rbf(x_point, y_point, move, function='thin-plate', epsilon=1, smooth=smooth) # interpolate in regular grid x_grid, y_grid = np.mgrid[0:shape[0], 0:shape[1]].astype(np.int32) # FIXME: it takes to much of RAM memory, for sample image more that 8GM ! deform = rbf(x_grid, y_grid) return deform
def interpolate_function(refgrid: np.ndarray, values: np.ndarray, grid: np.ndarray, function: str = 'gaussian'): """ Interpolate some function to an external grid. This method assumes that the reference values are evaluated on the class' box grid. Parameters ---------- refgrid : np.ndarray((n,3), dtype=float) Set of points where function was evaluated. function : np.ndarray(N, dtype=float) Reference function values to create interpolator. grid : np.ndarray((n, 3), dtype=float) Grid where the interpolant will be evalated. function : string Name of method for the interpolation. Options are: `linear`, `cubic`, `gaussian`. """ # Prepare arrays for interpolator xs = refgrid[:, 0] ys = refgrid[:, 1] zs = refgrid[:, 2] interpolator = interpolate.Rbf(xs, ys, zs, values, function=function) # Replace values previously stored grid[:, 3] = interpolator(grid[:, 0], grid[:, 1], grid[:, 2]) return grid
def build_interp_zack(obs_arr, cosmo_params, function='multiquadric', smooth=0.0): '''Build an interpolator: Input: (1) obs_arr has dimension (Npoints, Nbin), where Npoints = # of cosmological models (=100 here), and Nbins is the number of bins (2) cosmo_params has dimension (Npoints, Nparams) Output: spline_interps Usage: spline_interps = build_interp_zack(obs_arr, cosmo_params) spline_interps(_nu, Omega_m, A_s) ''' # create a list of Rbf for each independent mode spline_interps = [ interpolate.Rbf(*cosmo_params.T, model, function=function, smooth=smooth) for model in obs_arr.T ] # return a function that applies Rbf to the parameters given, for each mode return lambda params: np.array([ii(*params) for ii in spline_interps])
def buildInterpolator(obs_arr, cosmo_params): '''Build an interpolator: Input: (1) obs_arr has dimension (Npoints, Nbin), where Npoints = # of cosmological models (=100 here), and Nbins is the number of bins (2) cosmo_params has dimension (Npoints, Nparams), currently Nparams is hard-coded to be 3 (M_nu, Omega_m, A_s) Output: spline_interps Usage: spline_interps = buildInterpolator(obs_arr, cosmo_params) spline_interps(_nu, Omega_m, A_s) ''' param1, param2, param3 = cosmo_params.T spline_interps = list() for ibin in range(obs_arr.shape[-1]): model = obs_arr[:, ibin] ### Zack: I am using interpolate.Rbf here, but you can also try other ones, check https://docs.scipy.org/doc/scipy/reference/interpolate.html iinterp = interpolate.Rbf(param1, param2, param3, model) spline_interps.append(iinterp) def interp_cosmo(params): '''Interpolate the powspec for certain param. Params: list of 3 parameters = (M_nu, Omega_m, A_s) ''' mm, wm, sm = params gen_ps = lambda ibin: spline_interps[ibin](mm, wm, sm) ps_interp = array(map(gen_ps, range(obs_arr.shape[-1]))) ps_interp = ps_interp.reshape(-1, 1).squeeze() return ps_interp return interp_cosmo
def interpolate_measurements(measurements, interptype='griddata'): pts, z = measurements_to_cartesian_points(measurements) gridx, gridy = make_mesh_grid(pts) if interptype == 'griddata': grid = interpolate.griddata(pts, z, (gridx, gridy), method='linear', fill_value=-3e30) elif interptype == 'rbf': ptx, pty = list(zip(*pts)) f = interpolate.Rbf(ptx, pty, z, function='linear') grid = f(gridy, gridx) elif interptype == 'gauss': from sklearn.gaussian_process import GaussianProcess ptx, pty = list(zip(*pts)) ptx = np.array(ptx) pty = np.array(pty) z = np.array(z) print(math.sqrt(np.var(z))) gp = GaussianProcess(regr='quadratic', corr='cubic', theta0=np.min(z), thetaL=min(z), thetaU=max(z), nugget=0.05) gp.fit(X=np.column_stack([pty, ptx]), y=z) rr_cc_as_cols = np.column_stack([gridy.flatten(), gridx.flatten()]) grid = gp.predict(rr_cc_as_cols).reshape((ncol, nrow)) return gridx, gridy, grid
def transsectFromFile(Files): """Create 2d transsect from pnt Files""" X = [] F = [] y = [] #appen x,y, and force data to 3 arrays for file in Files: x, f = transsectGetValues(file.data[:, 0], file.data[:, 1]) surface = numpy.where(x >= file.surface)[0][0] ground = numpy.where(x >= file.ground)[0][0] X.append(x[surface:ground]) F.append(f[surface:ground]) y.append(len(y)) # Set up a regular grid of interpolation points xi, yi = numpy.linspace(X.min(), X.max(), len(X) / len(Files)), numpy.linspace( y.min(), y.max(), len(X) / len(Files)) xi, yi = numpy.meshgrid(xi, yi) # Interpolate rbf = interpolate.Rbf(X, y, F, function='linear') zi = rbf(xi, yi) plt.imshow(zi, vmin=F.min(), vmax=F.max(), origin='lower', extent=[X.min(), X.max(), y.min(), y.max()]) plt.scatter(X, y, c=F) plt.colorbar() plt.show()
def interpol(self, shpfile, att="ANN_PREC"): spatialref = shpfile["spatialref"] geomtype = shpfile["geomtype"] geomlist = shpfile["geomlist"] reclist = shpfile["reclist"] ref = spatialref.ExportToPrettyWkt() info_ = [] for i in range(len(geomlist)): gmt = geomlist[i] rec = reclist[i] gmt_ = ogr.CreateGeometryFromWkt(gmt) x, y, p = gmt_.GetX(), gmt_.GetY(), rec[att] info_.append([x, y, p]) info = np.array(info_) x = info[:, 0] # x coordinate y = info[:, 1] # y coordinate z = info[:, 2] # precipitation arrx = np.linspace( np.min(x), np.max(x), 100) #create 100 points in range bewtween minx and maxx arry = np.linspace(np.min(y), np.max(y), 100) xi, yi = np.meshgrid( arrx, arry) #Return coordinate matrices from coordinate vectors rbf = interpolate.Rbf( x, y, z, epsilon=2) # radial basis function interpolator instance zi = rbf(xi, yi) # interpolated values # zi = zi.tolist() 不好用,改变了维度2维变1维 orgnarr = [x, y, z] rtrnarr = [xi, yi, zi] return orgnarr, rtrnarr """
def _train_parameter_predictor(self, parameter_names): """Train interpolator/emulator for parameter prediction [y = f(vec{x})].""" training_data = [None] * (parameter_names.shape[0]) self._training_parameter_limts = np.zeros( (parameter_names.shape[0] - 1, 2)) for i, parameter_name in enumerate(parameter_names): if parameter_name in self.measured_param_names: parameter_index = self.measured_param_names[parameter_name] training_data_unnorm = self.measured_sample_params[:, parameter_index] parameter_limits = self.measured_param_limits[parameter_index] elif parameter_name in self.param_names: parameter_index = self.param_names[parameter_name] training_data_unnorm = self.sample_params[:, parameter_index] parameter_limits = self.param_limits[parameter_index] else: raise ValueError('Parameter name not recognised.') if i < (parameter_names.shape[0] - 1): training_data[i] = latin_hypercube.map_to_unit_cube_list( np.split(training_data_unnorm, training_data_unnorm.size), parameter_limits.reshape(1, -1)) self._training_parameter_limts[i, :] = parameter_limits else: training_data[i] = training_data_unnorm predictor = spi.Rbf(*training_data) return predictor
def interped_fourier_transformer(): """ Fourier transforms the combined FID signals of different chemical sites to give a frequency (NMR) spectrum. This is done after having used radial basis function interpolation to remove noise and smooth out high frequency signals that are not resolvable. """ dat, filename = pick_dat(['t', 'm'], 'RDAT') len2 = 2 * len(dat['m']) xs = np.linspace(np.min(dat['t']), np.max(dat['t']), len2) f = interpolate.Rbf(dat['t'], dat['m'], smooth=3, function='gaussian', epsilon=np.mean(np.diff(xs)) * 3) ys = f(xs) plt.plot(xs, -ys) fig_manager = plt.get_current_fig_manager() fig_manager.window.showMaximized() plt.show() sample_rate = round(1 / np.mean(np.diff(dat['t'])), 11) length = len(xs) fo = fftpack.fft(-ys) freq2 = fftpack.fftfreq(length, 1 / sample_rate) halfln = int(length / 2) plt.title('{}'.format(filename)) fig_manager = plt.get_current_fig_manager() fig_manager.window.showMaximized() plt.plot(dat['t'], dat['m']) plt.show() plt.title('{} Fourier Transformed'.format(filename)) plt.plot(freq2[1:halfln], abs(fo[1:halfln])) plt.xlim(0, 2000) fig_manager = plt.get_current_fig_manager() fig_manager.window.showMaximized() plt.show()
def rbf(local, x_data, num, name, ymax, ymin): name_list = [ 'X_displacement ', 'Y_displacement ', 'pressure', 'x_strain ', 'Y_strain', 'X_flow ', 'Y_flow', 'concentration ', "Young's modulus ", "Poisson's ratio", 'Permeability', 'S' ] ii = 96 y = np.int64(local / 1000) x = local % 1000 loc = np.zeros([len(x), 2], np.int64) loc = np.zeros([len(x), 2], np.int64) loc[:, 0] = np.int64(x - 1) loc[:, 1] = np.int64(y - 1) new_z = np.zeros([96, 96, 12]) xx = np.linspace(1, ii, ii) yy = np.linspace(1, ii, ii) grid_x, grid_y = np.mgrid[1:ii:96j, 1:ii:96j] for i in range(12): func = interpolate.Rbf(x - 1, y - 1, x_data[:, i], function='linear') new_z[:, :, i] = func(grid_x, grid_y) for paraa in range(12): sc = plt.scatter(x, y, c=(x_data[:, paraa]), vmin=ymin[paraa], vmax=ymax[paraa]) plt.colorbar(sc) plt.title('%s_%s_day_%d' % (name, name_list[paraa], num)) plt.savefig('e\\%s_%d_%d.png' % (name, paraa, num)) plt.clf() aa = cyka(loc, new_z, 12) return aa
def plot1020(values, electrodes, axis, head=True): ''' Interpolate and plot a color array of the scalp values: values to plot, excepts values between 0 and 1 (e.g. p values) electrodes: same size as values, the observed scalp electrodes axis: axis where the plot will be done head: plot the head reference returns a plot object that may be used for plt.colorbar the colormap used is a diverging map that changes around 0.1 in order to mark statistical significance ''' values = np.asarray(values) electrodes = np.asarray(electrodes) assert (values.size == electrodes.size) all_coords = get_1020coords() Xe = [] Ye = [] Ze = [] for ei in electrodes: x, y, z = all_coords[ei] Xe.append(x) Ye.append(y) Ze.append(z) Xe = np.asarray(Xe) Ye = np.asarray(Ye) Ze = np.asarray(Ze) gridpoints = np.linspace(-1, 1, 250) Xi, Yi = np.meshgrid(gridpoints, gridpoints) rbf = spi.Rbf(Xe, Ye, values, epsilon=0.25) # RBF ignoring Z coordinates Vi = np.ma.masked_array(rbf(Xi, Yi)) # Mask out of head values Vi[Xi**2 + Yi**2 > 1] = np.ma.masked #cmap = cm.bwr c = mcolors.ColorConverter().to_rgb cmap = make_colormap([c('red'), c('white'), 0.1, c('white'), c('blue')]) cres = axis.pcolor(Xi, Yi, Vi, cmap=cmap, vmin=0, vmax=1) if head: # plot fake head circle = np.linspace(0, 2 * np.pi, 1e3) xhead = np.sin(circle) yhead = np.cos(circle) axis.plot(xhead, yhead, color='k', linewidth=3) # plot projection of electrodes on Z=0 axis.plot(Ye, Xe, 'go') for i, elec in enumerate(electrodes): axis.text(Ye[i] + .05 * np.sign(Ye[i]), Xe[i] + .08 * np.sign(Xe[i]), elec) axis.set_xlim((-1.1, 1.1)) axis.set_ylim((-1.1, 1.1)) return cres
def map_to_stl(x_axis, y_axis, x, y, z, output_filename=None, show_plots=True): ''' This function interpolates a mesh from a set of 3D coordinates that define a 'map' (a function of two inputs `z = f(x,y)` ) using the Thin-Plate Spline method. A standard 3D-printable .stl (STereo-Lithography) file is saved to `output_filename` if provided. Args: x_axis, y_axis (np.array): 3D map axis x, y, z (np.array): Coordinates of points in 3-dimensional space. Coordinates can fall anywhere within the min/max of the provided axes. output_filename (str): Name of .stl file show_plots (bool): Turn on/off plotting ''' assert np.logical_and(x > min(x_axis), x < max( x_axis)).all(), " Coordinates must lie within the axes bounds" assert np.logical_and(y > min(y_axis), y < max( y_axis)).all(), " Coordinates must lie within the axes bounds" # Interpolate between points using the thin plate spline algorithm. interp = interpolate.Rbf(x, y, z, function='thin_plate') xi, yi = np.meshgrid(x_axis, y_axis) zi = interp(xi, yi) # Plot the initial interpolated surface. fig = plt.figure() ax_interp = axes3d.Axes3D(fig) ax_interp.plot_surface(xi, yi, zi, alpha=0.5) ax_interp.scatter3D(x, y, z, c="red") if show_plots: plt.show() # Begin mesh creation by triangulating the parameter space. points = np.array([xi.flatten(), yi.flatten()]).T tri = Delaunay(points) # Plot the triangulated surface. fig = plt.figure() ax_trisurf = axes3d.Axes3D(fig) ax_trisurf.plot_trisurf(xi.flatten(), yi.flatten(), zi.flatten(), triangles=tri.simplices, cmap=plt.cm.Spectral) if show_plots: plt.show() # Save result to a .stl file. if output_filename: vertices = points = np.array( [xi.flatten(), yi.flatten(), zi.flatten()]).T faces = tri.simplices map_mesh = mesh.Mesh(np.zeros(faces.shape[0], dtype=mesh.Mesh.dtype), ) for i, f in enumerate(faces): for j in range(3): map_mesh.vectors[i][j] = vertices[f[j], :] map_mesh.save(output_filename) return ax_interp, ax_trisurf,
def populateMissingData(self,approach="Smooth",ilog=None): ''' This function is used to interpolate missing data in the image. ''' if approach == 'Smooth': # first run a median filter over the array, then smooth the result. xmin,xmax,ymin,ymax,zmin,zmax = self.getRange() mask = np.array(self.flags,dtype=np.bool) z = self.getZImage().asMatrix2D() median = nd.median_filter(z,size=(15,15)) mask = mask.flatten() z = z.flatten() median = median.flatten() z[ mask==False ] = median[ mask==False ] if ilog != None: ilog.log(pv.Image(median.reshape(self.width,self.height)),label="Median") ilog.log(pv.Image(z.reshape(self.width,self.height)),label="ZMedian") mask = mask.flatten() z = z.flatten() median = median.flatten() for i in range(5): tmp = z.copy() smooth = nd.gaussian_filter(z.reshape(self.width,self.height),2.0).flatten() z[ mask==False ] = smooth[ mask==False ] print "Iteration:",i,(z-tmp).max(),(z-tmp).min() ilog.log(pv.Image(z.reshape(self.width,self.height)),label="ZSmooth%02d"%i) ilog.log(pv.Image((z-tmp).reshape(self.width,self.height)),label="ZSmooth%02d"%i) if approach == 'RBF': mask = np.array(self.flags,dtype=np.bool) mask = mask.flatten() x = np.arange(self.width).reshape(self.width,1) x = x*np.ones((1,self.height)) x = x.flatten() y = np.arange(self.height).reshape(1,self.height) y = y*np.ones((self.width,1)) y = y.flatten() z = self.z.copy() z = z.flatten() print "Coords:" print len(mask) print len(x[mask]) print len(y[mask]) print len(z[mask]) # this produces an error. Probably has too much data it.Rbf(x[mask],y[mask],z[mask]) pass