def genShiftVectorFieldSpline(nx, ny, nsx, nsy, err_sx, err_sy, bbox=None): """interpolates shift vectors using smoothing splines""" wonky = findWonkyVectors(nx, ny, nsx, nsy, tol=2 * err_sx.mean()) #wonky = findWonkyVectors(nx, ny, nsx, nsy, tol=100) good = wonky == 0 print(('%d wonky vectors found and discarded' % wonky.sum())) if bbox: spx = SmoothBivariateSpline(nx[good], ny[good], nsx[good], 1. / err_sx[good], bbox=bbox) spy = SmoothBivariateSpline(nx[good], ny[good], nsy[good], 1. / err_sy[good], bbox=bbox) else: spx = SmoothBivariateSpline(nx[good], ny[good], nsx[good], 1. / err_sx[good]) spy = SmoothBivariateSpline(nx[good], ny[good], nsy[good], 1. / err_sy[good]) X, Y = np.meshgrid(np.arange(0, 512 * 70, 100), np.arange(0, 256 * 70, 100)) dx = spx.ev(X.ravel(), Y.ravel()).reshape(X.shape) dy = spy.ev(X.ravel(), Y.ravel()).reshape(X.shape) return (dx.T, dy.T, spx, spy, good)
def df_fixer(df_path): """ There are usually holes/blank spots toward the outside of the df. The extrapolation we do isn't totally necessary, but it makes the later deformation have cleaner edges and the background color is much easier to fix. """ df = np.fromfile(df_path, dtype='float32', count=-1) df = df.reshape((256, 256, 3), order='F') df_R = df[:, :, 0] df_C = df[:, :, 1] # df_R += 1 # df_C += 1 # fill holes in df with spline interpolation/extrapolation [r1, c1] = np.where(df_R != -1) [rq, cq] = np.where(df_R == -1) splineR = SmoothBivariateSpline(r1, c1, df_R[r1, c1]) df_R[rq, cq] = splineR.ev(rq, cq) [r1, c1] = np.where(df_C != -1) [rq, cq] = np.where(df_C == -1) splineC = SmoothBivariateSpline(r1, c1, df_C[r1, c1]) df_C[rq, cq] = splineC.ev(rq, cq) return (df_R, df_C)
def calc_sig_dist_spline(x, y, xref, yref, n_iter=5, sig_clip=3, plot=False, smooth_fac=10000, wx=None, wy=None, ret_bool=False): #now sigma clip sbool = np.ones(x.shape, dtype='bool') for i in range(n_iter): #import pdb; pdb.set_trace() tx = Spline(x[sbool], y[sbool], xref[sbool] - x[sbool], s=smooth_fac, w=wx[sbool]) ty = Spline(x[sbool], y[sbool], yref[sbool] - y[sbool], s=smooth_fac, w=wy[sbool]) xout = tx.ev(x, y) yout = ty.ev(x, y) dx = xref - xout - x dy = yref - yout - y xcen = np.mean(dx[sbool]) xsig = np.std(dx[sbool]) ycen = np.mean(dy[sbool]) ysig = np.std(dy[sbool]) sbool_temp = (dx > xcen - sig_clip * xsig) * ( dx < xcen + sig_clip * xsig) * (dy > ycen - sig_clip * ysig) * ( dy < ycen + sig_clip * ysig) if i != n_iter - 1: sbool = sbool_temp * sbool print 'trimmed ', len(sbool) - np.sum(sbool), ' stars' if plot: print 'number of residuals outside of -5,5', np.sum((dx > 5) + (dx < -5) + (dy < -5) + (dy > 5)) plt.figure(35) plt.subplot(121) plt.hist(dx, bins=100, range=(-5, 5)) plt.title('X residual to fit') plt.subplot(122) plt.hist(dy, bins=100, range=(-5, 5)) plt.title('Y residual to fit') plt.show() if not ret_bool: return tx, ty, dx, dy else: return tx, ty, dx, dy, sbool
def model(x, y): spline = SmoothBivariateSpline( width, eqPonA, factor, kx=2, ky=1) result = spline.ev(x, y) return result
def plot_interpolated_image(P, I, file_name='plots/img.png', pregrid=False, dim=50): plt.clf() print 'plotting columns of matrix, shape: ', I.shape if (I.ndim == 1): I = I[:, None] f = 1 else: f = int(np.sqrt(I.shape[1])) for i in xrange(f**2): ax = plt.subplot(f,f,i+1) ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) xlim = ylim = 0.9 xi = np.linspace(-xlim, xlim, dim) yi = np.linspace(-ylim, ylim, dim) XI, YI = np.meshgrid(xi, yi) # grid the data. # contour the gridded data, plotting dots at the randomly spaced data points. if pregrid: # grid then spline smooth ZI = griddata((P[:, 0], P[:, 1]), I[:, i], (xi[None, :], yi[:, None]), method='linear', fill_value=np.mean(I[:, i])) spline = SmoothBivariateSpline(XI.flatten(), YI.flatten(), ZI.flatten()) else: spline = SmoothBivariateSpline(P[:, 0], P[:, 1], I[:, i]) zi = spline.ev(XI.flatten(), YI.flatten()) zi = np.reshape(zi, (dim,dim)) # rbf = Rbf(XI, YI, zi, epsilon=1e-1) # zz = rbf(XI, YI) plt.imshow(zi, interpolation='nearest') #plt.contour(xi,yi,zi,10, linewidths=0.5,colors='k') #plt.contourf(xi,yi,zi,10, cmap=plt.cm.spectral) #ax.scatter(P[:,0], P[:,1], c='k', s=2, linewidths=0) #plt.xlim(-1, 1) #plt.ylim(-1, 1) plt.savefig(file_name)
def genShiftVectorFieldSpline(nx,ny, nsx, nsy, err_sx, err_sy, bbox=None): '''interpolates shift vectors using smoothing splines''' wonky = findWonkyVectors(nx, ny, nsx, nsy, tol=2*err_sx.mean()) #wonky = findWonkyVectors(nx, ny, nsx, nsy, tol=100) good = wonky == 0 print(('%d wonky vectors found and discarded' % wonky.sum())) if bbox: spx = SmoothBivariateSpline(nx[good], ny[good], nsx[good], 1./err_sx[good], bbox=bbox) spy = SmoothBivariateSpline(nx[good], ny[good], nsy[good], 1./err_sy[good], bbox=bbox) else: spx = SmoothBivariateSpline(nx[good], ny[good], nsx[good], 1./err_sx[good]) spy = SmoothBivariateSpline(nx[good], ny[good], nsy[good], 1./err_sy[good]) X, Y = np.meshgrid(np.arange(0, 512*70, 100), np.arange(0, 256*70, 100)) dx = spx.ev(X.ravel(),Y.ravel()).reshape(X.shape) dy = spy.ev(X.ravel(),Y.ravel()).reshape(X.shape) return (dx.T, dy.T, spx, spy, good)
def spline_model(width_test, ratio_perim_area_test, width_data, ratio_perim_area_data, factor_data): """Return the result of the spline model. The bounding box is chosen so as to allow extrapolation. The spline orders are two in the width direction and one in the perimeter/area direction. For justification on using this method for modelling electron insert factors see the *Methods: Bivariate spline model* section within <http://dx.doi.org/10.1016/j.ejmp.2015.11.002>. Parameters ---------- width_test : np.ndarray The width point(s) which are to have the electron insert factor interpolated. ratio_perim_area_test : np.ndarray The perimeter/area which are to have the electron insert factor interpolated. width_data : np.ndarray The width data points for the relevant applicator, energy and ssd. ratio_perim_area_data : np.ndarray The perimeter/area data points for the relevant applicator, energy and ssd. factor_data : np.ndarray The insert factor data points for the relevant applicator, energy and ssd. Returns ------- result : np.ndarray The interpolated electron insert factors for width_test and ratio_perim_area_test. """ bbox = [ np.min([np.min(width_data), np.min(width_test)]), np.max([np.max(width_data), np.max(width_test)]), np.min([np.min(ratio_perim_area_data), np.min(ratio_perim_area_test)]), np.max([np.max(ratio_perim_area_data), np.max(ratio_perim_area_test)]) ] spline = SmoothBivariateSpline(width_data, ratio_perim_area_data, factor_data, kx=2, ky=1, bbox=bbox) return spline.ev(width_test, ratio_perim_area_test)
def model(x, y): bbox = [ np.min([np.min(width), np.min(x)]), np.max([np.max(width), np.max(x)]), np.min([np.min(eqPonA), np.min(y)]), np.max([np.max(eqPonA), np.max(y)])] spline = SmoothBivariateSpline( width, eqPonA, factor, kx=2, ky=1, bbox=bbox) result = spline.ev(x, y) return result
def model(x, y): bbox = [ np.min([np.min(width), np.min(x)]), np.max([np.max(width), np.max(x)]), np.min([np.min(eqPonA), np.min(y)]), np.max([np.max(eqPonA), np.max(y)]) ] spline = SmoothBivariateSpline(width, eqPonA, factor, kx=2, ky=1, bbox=bbox) result = spline.ev(x, y) return result
def spline_fit(x, y, z, evaluate=False, full_ccd=True, **interp_kwargs): """ spline fit to unstructured 3d data using scipy SmoothBivariateSpline. return callable and function evaluated over the pixels. Parameters: ----------- x, y, z: `array-like` data points to fit: f(x,y) = z evaluate: `bool` if True, evaluate the function over the pixels full_ccd: `bool` if you want to evaluate the model over a full CCD or just a RC. Returns: -------- spline function (+array) """ # smooth spline fit spline = SmoothBivariateSpline(x, y, z, **interp_kwargs) # eval spline over the pixels if evaluate: xmin, ymin = 0, 0 if full_ccd: xmin, ymin = -xsize, -ysize x_pix, y_pix = np.arange(xmin, xsize)[np.newaxis, ], np.arange( ymin, ysize)[:, np.newaxis] spline_arr = spline.ev(x_pix, y_pix) return spline, spline_arr else: return spline
yinput = np.repeat(heights, noa) zinput = data[:, plot_column, :].T.flatten() # f = interp2d(x = xinput, y = yinput, z = zinput, kind='cubic') # interpolate f = SmoothBivariateSpline(x=xinput, y=yinput, z=zinput) xnew = np.arange(min(x), max(x) + 0.5, 1) ynew = np.arange(min(heights), max(heights), 1) # znew = f(xnew, ynew) znew = np.zeros((len(ynew), len(xnew))) # evaluate interpolation function on new grid j = 0 i = 0 for y in ynew: for x in xnew: znew[i, j] = f.ev(x, y) j += 1 i += 1 j = 0 plt.imshow(znew, interpolation='hamming', origin='lower') # plt.colorbar() plt.title('Plasma Potential') plt.xlabel('Angle') plt.ylabel('Distance from target (mm)') plt.show()
# # plt.axis('off') fig.tight_layout() plt.savefig('fit.pdf', transparent=True) # plt.xlabel('Turbine Rating') # plt.ylabel('Rotor Diameter') # plt.title('Blade Mass') # # # # # fig, ax = plt.subplots(nrows=1, ncols=2, subplot_kw={'projection': '3d'}) # # ax[0].plot_wireframe(X, Y, Z_Vrated, color='k') # # # # ax[1].plot_wireframe(X, Y, Z_smooth_Vrated, color='k') # # # # # for axes in ax: # # # # axes.set_zlim(-0.2,1) # # # axes.set_axis_off() # # # # fig.tight_layout() # # plt.xlabel('Turbine Rating') # # plt.ylabel('Rotor Diameter') print len(w) plt.show() print interp_spline_blade_mass.get_coeffs() print interp_spline_blade_mass.ev(0.5, 0.5, dx=0, dy=1) print interp_spline_blade_mass.ev(0.5, 0.5, dx=1, dy=0) print interp_spline_blade_mass.ev(0.5, 0.5, dx=1, dy=1)
def implement_deform_timestep(sim, cells, t, p): """ Implements the deformation of the tissue cluster based on divergence-free deformation calculated for cell centres. """ # create a smooth bivariate spline to interpolate deformation data from cells: cellinterp_x = SmoothBivariateSpline(cells.cell_centres[:, 0], cells.cell_centres[:, 1], sim.d_cells_x, kx=4, ky=4) cellinterp_y = SmoothBivariateSpline(cells.cell_centres[:, 0], cells.cell_centres[:, 1], sim.d_cells_y, kx=4, ky=4) # calculate deformations wrt the ecm using the smooth bivariate spline: dxv = cellinterp_x.ev(cells.mem_verts[:, 0], cells.mem_verts[:, 1]) dyv = cellinterp_y.ev(cells.mem_verts[:, 0], cells.mem_verts[:, 1]) xv2 = cells.mem_verts[:, 0] + dxv yv2 = cells.mem_verts[:, 1] + dyv # calculate new cell centres: cell_cent_x = np.dot(cells.M_sum_mems, xv2 * cells.mem_sa) / cells.cell_sa cell_cent_y = np.dot(cells.M_sum_mems, yv2 * cells.mem_sa) / cells.cell_sa # smooth the vertices: # xv2 = sim.smooth_weight_mem*xv2 + cell_cent_x[cells.mem_to_cells]*sim.smooth_weight_o # yv2 = sim.smooth_weight_mem*yv2 + cell_cent_y[cells.mem_to_cells]*sim.smooth_weight_o # repackage the vertices: cell_verts2 = [] for i, pts in enumerate(cells.cell_verts): vx = xv2[cells.cell_to_mems[i]] vy = yv2[cells.cell_to_mems[i]] pts2 = np.column_stack((vx, vy)) cell_verts2.append(pts2) cells.cell_verts = np.asarray(cell_verts2) cells.cell_centres = np.column_stack((cell_cent_x, cell_cent_y)) # # calculate deformations wrt the ecm using the smooth bivariate spline: # decm_x = cellinterp_x.ev(cells.ecm_verts_unique[:, 0], cells.ecm_verts_unique[:, 1]) # decm_y = cellinterp_y.ev(cells.ecm_verts_unique[:, 0], cells.ecm_verts_unique[:, 1]) # # # get the new ecm verts by applying the deformation: # ecm_x2 = cells.ecm_verts_unique[:, 0] + decm_x # ecm_y2 = cells.ecm_verts_unique[:, 1] + decm_y # # ecm_new = np.column_stack((ecm_x2, ecm_y2)) # # # repackage new ecm vertices as cells.ecm_verts: # ecm_verts2 = [] # # for inds in cells.inds2ecmVerts: # ecm_verts2.append(ecm_new[inds]) # cells.ecm_verts = np.asarray(ecm_verts2) # rebuild essential portions of the cell world: # cells.deformWorld(p, ecm_verts2) # write data to time-storage vectors: sim.cell_centres_time.append(cells.cell_centres[:]) # sim.mem_mids_time.append(cells.mem_mids_flat[:]) # sim.maskM_time.append(cells.maskM[:]) # sim.mem_edges_time.append(cells.mem_edges_flat[:]) sim.cell_verts_time.append(cells.cell_verts[:])
DME, IELCON = ass.DME(IBC, ne, elements) KG = ass.matassem(IBC, mats, elements, nn, ne, neq, COORD, DME, IELCON) RHSG = ass.loadasem(loads, IBC, neq, nl) #%% SYSTEM SOLUTION UG = np.linalg.solve(KG, RHSG) if not (np.allclose(np.dot(KG, UG), RHSG)): print("The system is not in equilibrium!") #%% POST-PROCCESSING UC = pos.complete_disp(IBC, nodes, UG) pos.plot_disp(UC, nodes, elements) UU = pos.scatter(DME, UG, ne, neq, elements) x = nodes[:, 1] y = nodes[:, 2] E_gauss, pts_gauss = pos.strainGLO(IELCON, UU, ne, COORD, elements) E_int1 = SmoothBivariateSpline(pts_gauss[:, 0], pts_gauss[:, 1], E_gauss[:, 0]) E_int2 = SmoothBivariateSpline(pts_gauss[:, 0], pts_gauss[:, 1], E_gauss[:, 1]) E_int3 = SmoothBivariateSpline(pts_gauss[:, 0], pts_gauss[:, 1], E_gauss[:, 2]) E1 = E_int1.ev(x, y) E2 = E_int2.ev(x, y) E3 = E_int3.ev(x, y) E_nodes = np.column_stack([E1, E2, E3]) pos.plot_strain(E_nodes, nodes, elements, plt_type="pcolor") tri = pos.mesh2tri(nodes, elements) plt.triplot(tri, color='k', alpha=0.3) plt.show()
UG = np.linalg.solve(KG, RHSG) if not(np.allclose(np.dot(KG, UG), RHSG)): print("The system is not in equilibrium!") #%% POST-PROCCESSING UC = pos.complete_disp(IBC, nodes, UG) pos.plot_disp(UC, nodes, elements) UU = pos.scatter(DME, UG, ne, neq, elements) x = nodes[:, 1] y = nodes[:, 2] E_gauss, pts_gauss = pos.strainGLO(IELCON, UU, ne, COORD, elements) E_int1 = SmoothBivariateSpline(pts_gauss[:, 0], pts_gauss[:, 1], E_gauss[:, 0]) E_int2 = SmoothBivariateSpline(pts_gauss[:, 0], pts_gauss[:, 1], E_gauss[:, 1]) E_int3 = SmoothBivariateSpline(pts_gauss[:, 0], pts_gauss[:, 1], E_gauss[:, 2]) E1 = E_int1.ev(x, y) E2 = E_int2.ev(x, y) E3 = E_int3.ev(x, y) E_nodes = np.column_stack([E1, E2, E3]) pos.plot_strain(E_nodes, nodes, elements, plt_type="pcolor") tri = pos.mesh2tri(nodes, elements) plt.triplot(tri, color='k', alpha=0.3) plt.show()
print('Splines (with linear extrapolation) : {} s per call'.format((s-t)/10/n_v)) print( 'Max error : {}'.format(abs(out-true_vals).max()) ) print( 'Mean error : {}'.format(abs(out-true_vals).mean()) ) if d == 2: print('') from scipy.interpolate import SmoothBivariateSpline grid_x = grid[0,:] grid_y = grid[1,:] values = mvs.values[0,:] bs = SmoothBivariateSpline(grid_x, grid_y, values) t = time.time() for i in range(10): out = bs.ev(points[0,:], points[1,:]) s = time.time() print('Splines (smooth splines from scipy) : {} s per call'.format((s-t)/10)) print( 'Max error : {}'.format(abs(out-true_vals).max()) ) print( 'Mean error : {}'.format(abs(out-true_vals).mean()) )