def buildSection(self, xo = None, yo = None, xm = None, ym = None, pts = 100, gfilter = 5): """ Extract a slice from the 3D data set and compute the stratigraphic layers. Parameters ---------- variable: xo, yo Lower X,Y coordinates of the cross-section. variable: xm, ym Upper X,Y coordinates of the cross-section. variable: pts Number of points to discretise the cross-section. variable: gfilter Gaussian smoothing filter. """ if xm > self.x.max(): xm = self.x.max() if ym > self.y.max(): ym = self.y.max() if xo < self.x.min(): xo = self.x.min() if yo < self.y.min(): yo = self.y.min() xsec, ysec = self._cross_section(xo, yo, xm, ym, pts) self.dist = np.sqrt(( xsec - xo )**2 + ( ysec - yo )**2) self.xsec = xsec self.ysec = ysec for k in range(self.nz): # Thick rect_B_spline = RectBivariateSpline(self.yi, self.xi, self.th[:,:,k]) data = rect_B_spline.ev(ysec, xsec) secTh = filters.gaussian_filter1d(data,sigma=gfilter) secTh[secTh < 0] = 0 self.secTh.append(secTh) # Elev rect_B_spline1 = RectBivariateSpline(self.yi, self.xi, self.elev[:,:,k]) data1 = rect_B_spline1.ev(ysec, xsec) secElev = filters.gaussian_filter1d(data1,sigma=gfilter) self.secElev.append(secElev) # Depth rect_B_spline2 = RectBivariateSpline(self.yi, self.xi, self.dep[:,:,k]) data2 = rect_B_spline2.ev(ysec, xsec) secDep = filters.gaussian_filter1d(data2,sigma=gfilter) self.secDep.append(secDep) # Ensure the spline interpolation does not create underlying layers above upper ones topsec = self.secDep[self.nz-1] for k in range(self.nz-2,-1,-1): secDep = self.secDep[k] self.secDep[k] = np.minimum(secDep, topsec) topsec = self.secDep[k] return
def __init__(self, periods): """ Create an instance of LB13. Args: periods (numpy.array): An array of periods that will be requested from the function. Values must be [0.01 -> 10.0], and must me sorted from smallest to largest. Returns: An instance of :class:`LothBaker2013`. """ if np.any(periods < 0.01): raise ValueError('The periods must be greater or equal to 0.01s') if np.any(periods > 10): raise ValueError('The periods must be less or equal to 10s') rbs1 = RectBivariateSpline(Tlist, Tlist, B1, kx=1, ky=1) rbs2 = RectBivariateSpline(Tlist, Tlist, B2, kx=1, ky=1) rbs3 = RectBivariateSpline(Tlist, Tlist, B3, kx=1, ky=1) # # Build new tables with entries at the periods we will use # tlist = list(zip(*it.product(periods, periods))) nper = np.size(periods) self.b1 = rbs1.ev(tlist[0], tlist[1]).reshape((nper, nper)) self.b2 = rbs2.ev(tlist[0], tlist[1]).reshape((nper, nper)) self.b3 = rbs3.ev(tlist[0], tlist[1]).reshape((nper, nper))
def main(): filenameEffArea='aeff_P7REP_ULTRACLEAN_V15_back.fits' directoryEffectiveArea='/Users/dspolyar/Documents/IRF/EffectiveArea/' print pyfits.info( directoryEffectiveArea+filenameEffArea) CTHETA_LO, CTHETA_HI, energyLow, energyHigh, EFFAREA = importEffectiveArea(directoryEffectiveArea+filenameEffArea) energylog, Ctheta=centeringDataAndConvertingToLog(energyHigh,energyLow,CTHETA_HI,CTHETA_LO) SplineEffectiveArea=RectBivariateSpline(Ctheta,energylog,EFFAREA) plotofEffectiveArea(SplineEffectiveArea,EFFAREA,energylog,Ctheta) print SplineEffectiveArea.ev(1.,5.)
def LucasKanadeAffine(It, It1): # Input: # It: template image # It1: Current image # Output: # M: the Affine warp matrix [2x3 numpy array] # put your implementation here M = np.array([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]) p = M.flatten() x1, y1, x2, y2 = 0, 0, It.shape[1] - 1, It.shape[0] - 1 threshold = 1e-3 dp = np.array([float("inf")] * 6) interpolated_It1 = RectBivariateSpline( x=np.array([i for i in range(int(It1.shape[0]))]), y=np.array([i for i in range(int(It1.shape[1]))]), z=It1) while np.sum(np.square(dp)) >= threshold: x = np.arange(x1, x2 + .5) y = np.arange(y1, y2 + .5) X = np.array([x for i in range(len(y))]) Y = np.array([y for i in range(len(x))]).T warp_X = p[0] * X + p[1] * Y + p[2] warp_Y = p[3] * X + p[4] * Y + p[5] valid_points = (warp_X >= x1) & (warp_X <= x2) & (warp_Y >= y1) & (warp_Y <= y2) X, Y = X[valid_points], Y[valid_points] warp_X, warp_Y = warp_X[valid_points], warp_Y[valid_points] warp_It1x = interpolated_It1.ev(warp_Y, warp_X) dx = interpolated_It1.ev(warp_Y, warp_X, dx=0, dy=1).flatten() dy = interpolated_It1.ev(warp_Y, warp_X, dx=1, dy=0).flatten() A = np.array([ dx * X.flatten(), dx * Y.flatten(), dx, dy * X.flatten(), dy * Y.flatten(), dy, ]).T b = (It[valid_points] - warp_It1x).flatten() dp = np.dot(np.linalg.inv(np.dot(A.T, A)), np.dot(A.T, b)) p += dp.flatten() M = np.copy(p).reshape(2, 3) M = np.vstack((M, np.array([[0, 0, 1]]))) return M
def LucasKanade(It, It1, rect, threshold, num_iters, p0=np.zeros(2)): """ :param It: template image :param It1: Current image :param rect: Current position of the car (top left, bot right coordinates) :param threshold: if the length of dp is smaller than the threshold, terminate the optimization :param num_iters: number of iterations of the optimization :param p0: Initial movement vector [dp_x0, dp_y0] :return: p: movement vector [dp_x, dp_y] """ # Put your implementation here p = p0 x1, y1, x2, y2 = rect[0], rect[1], rect[2], rect[3] It_spline = RectBivariateSpline(np.arange(It.shape[0]), np.arange(It.shape[1]), It) It1_spline = RectBivariateSpline(np.arange(It1.shape[0]), np.arange(It1.shape[1]), It1) dp = np.array([float("inf"), float("inf")]) count = 0 x = np.arange(x1, x2 + 1) y = np.arange(y1, y2 + 1) x, y = np.meshgrid(x, y) while np.linalg.norm(dp) >= threshold and count <= num_iters: count += 1 Itx = It_spline.ev(y, x).flatten() It1x_warp = It1_spline.ev(y + p[1], x + p[0]).flatten() A = np.array([ It1_spline.ev(y + p[1], x + p[0], dx=0, dy=1).flatten(), It1_spline.ev(y + p[1], x + p[0], dx=1, dy=0).flatten() ]).T # print(np.shape(A)) b = (Itx - It1x_warp).flatten() # print(np.shape(b)) dp = (np.linalg.inv(A.T @ A)) @ (A.T @ b) p += dp return p
def getEroDep(self, xo=None, yo=None, xm=None, ym=None, pts=100, gfilter=5): """ Extract a slice from the 3D data set and compute its deposition thicknesses. Parameters ---------- variable: xo, yo Lower X,Y coordinates of the cross-section variable: xm, ym Upper X,Y coordinates of the cross-section variable: pts Number of points to discretise the cross-section variable: gfilter Gaussian smoothing filter """ if xm > self.x.max(): xm = self.x.max() if ym > self.y.max(): ym = self.y.max() if xo < self.x.min(): xo = self.x.min() if yo < self.y.min(): yo = self.y.min() xsec, ysec = self._cross_section(xo, yo, xm, ym, pts) self.dist = np.sqrt((xsec - xo)**2 + (ysec - yo)**2) # Surface rect_B_spline = RectBivariateSpline(self.y[:, 0], self.x[0, :], self.z) datatop = rect_B_spline.ev(ysec, xsec) self.top = filters.gaussian_filter1d(datatop, sigma=gfilter) # Cumchange rect_B_spline = RectBivariateSpline(self.y[:, 0], self.x[0, :], self.cumchange) cumdat = rect_B_spline.ev(ysec, xsec) gcum = filters.gaussian_filter1d(cumdat, sigma=gfilter) self.depo = gcum.clip(min=0) return
class GridSag(ExplicitShape): """ Class for gridsag """ def __init__(self, lc, xxx_todo_changeme, name="", *args, **kwargs): (xlinspace, ylinspace, Zgrid) = xxx_todo_changeme kwargs_dict = kwargs name = kwargs_dict.pop('name', '') self.interpolant = RectBivariateSpline(xlinspace, ylinspace, Zgrid) #self.interpolant = interp2d(xlinspace, ylinspace, Zgrid, kind=kind, *args, **kwargs_dict) def gsf(x, y): res = self.interpolant.ev(x, y) return res def gradgsf(x, y, z): # gradient for implicit function z - af(x, y) = 0 res = np.zeros((3, len(x))) res[0, :] = -self.interpolant.ev(x, y, dx=1) res[1, :] = -self.interpolant.ev(x, y, dy=1) res[2, :] = 1. return res def hessgsf(x, y, z): res = np.zeros((3, 3, len(x))) res[0, 0, :] = -self.interpolant.ev(x, y, dx=2) res[0, 1, :] = res[1, 0, :] = -self.interpolant.ev(x, y, dx=1, dy=1) res[1, 1, :] = -self.interpolant.ev(x, y, dy=2) return res super(GridSag, self).__init__(lc, gsf, gradgsf, hessgsf, eps=1e-4, iterations=10, name=name) def setKind(self): self.kind = "shape_GridSag"
def SubtractDominantMotion(image1, image2): # Input: # Images at time t and t+1 # Output: # mask: [nxm] # put your implementation here mask = np.zeros(image1.shape, dtype=bool) # M = LucasKanadeAffine.LucasKanadeAffine(image1, image2) # use efficient method M = InverseCompositionAffine.InverseCompositionAffine(image1, image2) if M.shape[0] < 3: M = np.vstack((M, np.array([[0, 0, 1]]))) M = np.linalg.inv(M) interp_spline_image1 = RectBivariateSpline(np.arange(image1.shape[0]), np.arange(image1.shape[1]), image1) interp_spline_image2 = RectBivariateSpline(np.arange(image2.shape[0]), np.arange(image2.shape[1]), image2) # project coordinates to interpolate the values x = np.arange(0, image2.shape[1]) y = np.arange(0, image2.shape[0]) X, Y = np.meshgrid(x, y) X_ = M[0, 0] * X + M[0, 1] * Y + M[0, 2] Y_ = M[1, 0] * X + M[1, 1] * Y + M[1, 2] # get the invalid positions that are not common ares in two images invalid = (X_ < 0) | (X_ >= image1.shape[1]) | (Y_ < 0) & (Y_ >= image1.shape[0]) interped_I1 = interp_spline_image1.ev(Y_, X_) interped_I2 = interp_spline_image2.ev(Y, X) interped_I1[invalid] = 0 interped_I2[invalid] = 0 # calculate the difference diff = abs(interped_I2 - interped_I1) th = 0.1 ind = (diff > th) & (interped_I2 != 0) mask[ind] = 1 ker = np.array(([0, 0, 1, 0, 0], [0, 1, 1, 1, 0], [1, 1, 1, 1, 1], [0, 1, 1, 1, 0], [0, 0, 1, 0, 0])) mask = mp.binary_dilation(mask, structure=ker).astype(mask.dtype) return mask
def InverseCompositionAffine(It, It1, threshold, num_iters): """ :param It: template image :param It1: Current image :param threshold: if the length of dp is smaller than the threshold, terminate the optimization :param num_iters: number of iterations of the optimization :return: M: the Affine warp matrix [2x3 numpy array] """ # put your implementation here p = np.zeros(6) M = np.array([[1.0 + p[0], p[1], p[2]], [p[3], 1.0 + p[4], p[5]]]) template_height, template_width = It.shape[0], It.shape[1] image_height, image_width = It1.shape[0], It1.shape[1] x_range = np.arange(0, template_width, 1) y_range = np.arange(0, template_height, 1) # get rectangular splines interpolated_template_spline = RectBivariateSpline(y_range, x_range, It) interpolated_current_image_spline = RectBivariateSpline(np.arange(0, image_height, 1), np.arange(0, image_width, 1), It1) # get template grid xv, yv = np.meshgrid(x_range, y_range) xv, yv = xv.reshape(1, -1), yv.reshape(1, -1) template = np.vstack((xv, yv, np.ones((1, template_height * template_width)))) grad_x = interpolated_current_image_spline.ev(yv, xv, dy=1).flatten() grad_y = interpolated_current_image_spline.ev(yv, xv, dx=1).flatten() jacobian_gd = np.vstack((xv * grad_x, yv * grad_x, grad_x, xv * grad_y, yv * grad_y, grad_y)) h = np.linalg.pinv(jacobian_gd) for i in range(num_iters): warped_image = np.dot(M, template) interpolated_template = interpolated_template_spline.ev(yv, xv).flatten() interpolated_current_image = interpolated_current_image_spline.ev(warped_image[1, :], warped_image[0, :]).flatten() difference = interpolated_template - interpolated_current_image dp = np.dot(h.T, difference) p += dp M = np.array([[1.0 + p[0], p[1], p[2]], [p[3], 1.0 + p[4], p[5]]]) if np.linalg.norm(dp) <= threshold: break return M
def setModel(self,model,dx,think_positive=False): ''' Set new model for the source. :param model: ``(n, n)`` Numpy image array. :param dx: scalar Pixel size in microarcseconds. :param think_positive: (optional) bool Should we enforce that the source image has no negative pixel values? ''' self.nx = int(ceil(model.shape[-1] * dx / self.dx)) # number of image pixels self.model = model # source model self.model_dx = dx # source model resolution # load source image that has size and resolution compatible with the screen. self.isrc = np.empty(2*(self.nx,)) self.think_positive = think_positive M = self.model.shape[1] # size of original image array f_img = RectBivariateSpline(self.model_dx/self.dx*(np.arange(M) - 0.5*(M-1)),\ self.model_dx/self.dx*(np.arange(M) - 0.5*(M-1)),\ self.model) xx_,yy_ = np.meshgrid((np.arange(self.nx) - 0.5*(self.nx-1)),\ (np.arange(self.nx) - 0.5*(self.nx-1)),indexing='xy') m = f_img.ev(yy_.flatten(),xx_.flatten()).reshape(2*(self.nx,)) self.isrc = m * (self.dx/self.model_dx)**2 # rescale for change in pixel size if self.think_positive: self.isrc[self.isrc < 0] = 0 if not self.live_dangerously: self._checkSanity()
def transform(self, sourceImage, destinationImage): # - Verify that both input arguments are numpy arrays, if not isinstance(sourceImage, np.ndarray) or not isinstance( destinationImage, np.ndarray): raise TypeError('One or more images not np arrays') # - affine transformation from the triangle in the source image to its corresponding triangle # 1st step: create mask length, width = destinationImage.shape img = Image.new('L', (width, length), 0) vertices = [(x, y) for [x, y] in self.destination] ImageDraw.Draw(img).polygon(vertices, outline=255, fill=255) mask = np.array(img) # 2nd step: create H inverse and get bivariate spline approximation H_inv = np.linalg.inv(self.matrix) x = np.arange(length) y = np.arange(width) approx = RectBivariateSpline(x, y, sourceImage, kx=1, ky=1) #get each point in mask whose value is greater than 0 for yp, xp in np.transpose(np.nonzero(mask)): #H^-1 * [x' y' 1] = [x y 1] P = H_inv.dot([xp, yp, 1])[0:2] #2d interpolation to obtain a value if x y are floats shade = np.round(approx.ev(P[1], P[0])) #assign that value to x' y' destinationImage[yp][xp] = shade
def calcAnker(IS, inputPoints, rasterdata, gp): """ """ dhm = rasterdata['subraster'] [Xa, Ya, Xe, Ye] = inputPoints # Letzte Koordinate in xi/yi entspricht nicht exakt den Endkoordinaten Xe_ = gp['xi'][-1] Ye_ = gp['yi'][-1] AnkA_dist = IS['d_Anker_A'][0] AnkE_dist = IS['d_Anker_E'][0] stueA_H = IS['HM_Anfang'][0] stueE_H = IS['HM_Ende_max'][0] # X- und Y-Koordinate der Geodaten im Projektionssystem berechnen dx = float(Xe - Xa) dy = float(Ye - Ya) if dx == 0: dx = 0.0001 azimut = math.atan(dy/dx) if dx > 0: azimut += 2 * math.pi else: azimut += math.pi # X- und Y-Koordinaten der beiden Ankerpunkte am Boden AnkXa = Xa - AnkA_dist * math.cos(azimut) AnkYa = Ya - AnkA_dist * math.sin(azimut) AnkXe = Xe_ + AnkE_dist * math.cos(azimut) AnkYe = Ye_ + AnkE_dist * math.sin(azimut) # Linear Interpolation # Koordinatenarrays des DHMs coordX = gp['linspaces'][0] coordY = gp['linspaces'][1] # kx, ky bezeichnen grad der interpolation, 1=linear spline = RectBivariateSpline(-coordY, coordX, dhm, kx=1, ky=1) xi = np.array([AnkXa, Xa, Xe_, AnkXe]) yi = np.array([AnkYa, Ya, Ye_, AnkYe]) # Z-Koordinate der Anker für Anfangs- und Endpunkte zAnker = spline.ev(-yi, xi) # Höhenangaben am Boden AnkA_z = stueA_H + 0.1*(zAnker[1] - zAnker[0]) AnkE_z = stueE_H + 0.1*(zAnker[2] - zAnker[3]) if AnkA_dist == 0: AnkA_z = 0.0 if AnkE_dist == 0: AnkE_z = 0.0 Ank = [AnkA_dist, AnkA_z, AnkE_dist, AnkE_z] # Ausdehnungen der Anker Felder, alles in [m] #Ank = [d_Anker_A, z_Anker_A * 0.1, d_Anker_E, z_Anker_E * 0.1] Laenge_Ankerseil = (AnkA_dist**2 + AnkA_z**2)**0.5 + \ (AnkE_dist**2 + AnkE_z**2)**0.5 # Eventuell nicht nötig #IS['z_Anker_A'][0] = z_Anker_A #IS['z_Anker_E'][0] = z_Anker_E return [Ank, Laenge_Ankerseil, zAnker]
def skybg_phot(x0, y0, data, r=25, dr=5, samp=3, debug=False): # determine img indexes for aperture region xv, yv = mesh_box([x0, y0], (r + dr) + 2) # derive indexs on a higher resolution grid and create aperture mask px, py, mask = sky_annulus(x0, y0, r=r, samp=xv.shape[0] * samp) # interpolate original data onto higher resolution grid subdata = data[yv, xv] model = RectBivariateSpline(np.unique(xv), np.unique(yv), subdata) # evaluate data on highres grid pz = model.ev(px, py) # zero out pixels larger than radius pz[~mask] = 0 pz[pz < 0] = 0 # scale area back to original grid, total flux in sky annulus parea = pz.sum() * np.diff(px).mean() * np.diff(py[:, 0]).mean() if debug: print('mask area=', mask.sum() * np.diff(px).mean() * np.diff(py[:, 0]).mean()) print('true area=', 2 * np.pi * r * dr) print('subdata flux=', subdata.sum()) print('bg phot flux=', parea) import pdb pdb.set_trace() # return bg value per pixel return pz.sum() / mask.sum()
def plot(self, ax, V=None, **kwargs): '''Plot the contours into matplotlib axis. Parameters ---------- ax : matplotlib.Axes Axes to plot into V : array-like A list of contour values to plot. If not None, the internal contour values will be overriden during plotting, but not inside the object. kwargs : dict Keyword arguments to pass on to the ax.contour() method. ''' if V is None: V = self.V d, X, Y = self.data.getData() # hack - add zero value to close contours d = np.hstack((d, np.zeros((d.shape[0], 1)))) d = np.vstack((d, np.zeros((1, d.shape[1])))) dx = X[0, 1] - X[0, 0] dy = Y[1, 0] - Y[0, 0] x_longer = X[0, :].tolist() x_longer.append(X[0, -1] + dx) y_longer = Y[:, 0].tolist() y_longer.append(Y[-1, 0] + dy) x_interp, y_interp = np.meshgrid( np.linspace(x_longer[0], x_longer[-1], len(x_longer) * self.upsample_factor), np.linspace(x_longer[0], y_longer[-1], len(y_longer) * self.upsample_factor)) spl = RectBivariateSpline(x_longer, y_longer, d.T) d_interp = spl.ev(x_interp, y_interp) ax.contour(x_interp, y_interp, d_interp, V, **kwargs)
def interpolate_individual(self, image): # unpacking ogridx, ogridy = self.ogrid ngridx, ngridy = self.ngrid f = RectBivariateSpline(ogridy, ogridx, image, kx=1, ky=1) return f.ev(ngridy.flatten(), ngridx.flatten()).reshape(ngridx.shape)
def _mesh_interpolate_worker(args): coords, raster, crs, chunk_size = args raster = Raster(raster) raster.warp(crs) results = [] for window in raster.iter_windows(chunk_size=chunk_size, overlap=2): xi = raster.get_x(window) yi = raster.get_y(window) zi = raster.get_values(window=window) f = RectBivariateSpline( xi, np.flip(yi), np.fliplr(zi).T, bbox=[np.min(xi), np.max(xi), np.min(yi), np.max(yi)], kx=3, ky=3, s=0) idxs = np.where( np.logical_and( np.logical_and( np.min(xi) < coords[:, 0], np.max(xi) > coords[:, 0]), np.logical_and( np.min(yi) < coords[:, 1], np.max(yi) > coords[:, 1])))[0] values = f.ev(coords[idxs, 0], coords[idxs, 1]) results.append((idxs, values)) return results
def _get_above_cloud_r_and_dr(self, P_profile, T_profile, abundances, planet_mass, planet_radius, star_radius, above_cloud_cond, T_star=None): assert (len(P_profile) == len(T_profile)) # First, get atmospheric weight profile mu_profile = np.zeros(len(P_profile)) for species_name in abundances: interpolator = RectBivariateSpline(self.P_grid, self.T_grid, abundances[species_name], kx=1, ky=1) atm_abundances = interpolator.ev(P_profile, T_profile) mu_profile += atm_abundances * self.mass_data[species_name] return _hydrostatic_solver._solve(P_profile, T_profile, self.ref_pressure, mu_profile, planet_mass, planet_radius, star_radius, above_cloud_cond, T_star)
def regrid_imagery(image, x_image, y_image, x_regrid, y_regrid, image_proj, regrid_proj, spline_kws=None): """ For a given image, regrid it to another projection using spline interpolation. Args: image: x_image: y_image: x_regrid: y_regrid: image_proj: regrid_proj: spline_kws: Returns: """ if spline_kws is None: spline_kws = dict() x_regrid_image, y_regrid_image = transform(image_proj, regrid_proj, x_regrid.ravel(), y_regrid.ravel()) rbs = RectBivariateSpline(x_image, y_image, image, **spline_kws) regridded_image = rbs.ev(x_regrid_image, y_regrid_image).reshape(x_regrid.shape) return regridded_image
def get_pixels(self, DU, DV, image): """Return pixel values for each xyz point from the image Arguments: DU (np.ndarray): Pixel location in camera orientation and coordinate system DV (np.ndarray): Pixel location in cmaera orientation and coorindate system Returns: K (np.ndarray): Pixel intensity for each point in the image """ K = np.zeros((self.target_grid.X.shape[0], self.target_grid.X.shape[1], self.ncolors)) for c, _ in enumerate(['r', 'b', 'g']): rbs = RectBivariateSpline( # use this range to match matlab exactly np.arange(1, image.shape[0] + 1), np.arange(1, image.shape[1] + 1), image[:, :, c], kx=1, ky=1) K[:, :, c] = rbs.ev(DV, DU) # mask out values out of range like matlab # avoid runtime nan comparison warning (UV, DV already have nans) with np.errstate(invalid='ignore'): mask_u = np.logical_or(DU <= 1, DU >= image.shape[1]) mask_v = np.logical_or(DV <= 1, DV >= image.shape[0]) mask = np.logical_or(mask_u, mask_v) K[mask] = np.nan return K
def get_elevations(subpaths, ufnames, flagsmissing): interpvalues = np.empty(0, dtype=int) for i in range(len(subpaths)): # open srtmdata filename according to subpath path = Path.joinpath(hgtpath, ufnames[i]) if not flagsmissing[i]: with open(path, 'rb') as data: # data is stored in srtmdata files in big-endian format: # SRTM1 (1-arc sampling) is used, so each file contains 3601x3601 individual elevations # after reading all elevatin ins file, we reshape it into a rectangular numpy array elevationdata = np.fromfile(data, np.dtype('>i2'), 3601**2).reshape(3601, 3601) # interpolate elevation values with scipy.interpolate.griddata f1 = RectBivariateSpline(x, x, elevationdata, kx=1, ky=1) latcorr = int(ufnames[i][1:3]) + 1 loncorr = int(ufnames[i][4:7]) interpvalues = np.hstack((interpvalues, f1.ev(latcorr - subpaths[i][0], subpaths[i][1] - loncorr))) else: interpvalues = np.hstack( (interpvalues, np.zeros_like(subpaths[i][0]))) return interpvalues
def put_psf_on_subarray(psf, y, frame_height=256): """Make a 2D SOSS trace from a sequence of psfs and trace center locations Parameters ---------- psf: sequence The 2D psf y: float The grid y value to place the center of the psf grid: sequence The [x, y] grid ranges Returns ------- np.ndarray The 2D frame with the interpolated psf """ # Create spline generator dim = psf.shape[0] mid = (dim - 1.0) / 2.0 arr = np.arange(dim, dtype=np.float) spline = RectBivariateSpline(arr, arr, psf.T, kx=3, ky=3, s=0) # Create output frame, shifted as necessary yg, xg = np.indices((frame_height, dim), dtype=np.float64) yg += mid - y # Resample onto the subarray frame = spline.ev(xg, yg) # Fill resampled points with zeros extrapol = (((xg < -0.5) | (xg >= dim - 0.5)) | ((yg < -0.5) | (yg >= dim - 0.5))) frame[extrapol] = 0 return frame
def Transformation(self, originalImage, targetImage, Target, original): # this is image # print(targetimage) # print(xp,yp) #NbyTwo[:, [0, 1]] = NbyTwo[:, [1, 0]] NbyTwo = Target.getPoints() #getCoord = np.vectorize(lambda x, y, a: self.inverseMatrix[a, 0] * y + self.inverseMatrix[a, 1] * x + self.inverseMatrix[a, 2], otypes=[np.float64]) #NbyTwo[:, [1, 0]] = NbyTwo[:, [0, 1]] xp, yp = np.transpose( NbyTwo ) ## this will return the points reside in one triangle, in morpher x = self.calcXPoints(xp, yp) y = self.calcYPoints(xp, yp) # xdim = np.array([a for a in range(int(min(original.vertices[:, 1])), int(max(original.vertices[:, 1])))]) # # print(len(xdim)) # ydim = np.array([a for a in range(int(min(original.vertices[:, 0])), int(max(original.vertices[:, 0])))]) # # xyVal = originalImage[xdim[0]:xdim[len(xdim) - 1]+1, ydim[0]:ydim[len(ydim) - 1]+1] xdim = np.arange(np.amin(original.vertices[:, 1]), np.amax(original.vertices[:, 1]), 1) ydim = np.arange(np.amin(original.vertices[:, 0]), np.amax(original.vertices[:, 0]), 1) xyVal = originalImage[int(xdim[0]):int(xdim[-1] + 1), int(ydim[0]):int(ydim[-1] + 1)] bilinear = RectBivariateSpline(xdim, ydim, xyVal, kx=1, ky=1) targetImage[xp, yp] = bilinear.ev(x, y)
def _get_above_cloud_profiles(self, P_profile, T_profile, abundances, planet_mass, planet_radius, star_radius, above_cloud_cond, T_star=None): assert(len(P_profile) == len(T_profile)) # First, get atmospheric weight profile mu_profile = np.zeros(len(P_profile)) atm_abundances = {} for species_name in abundances: interpolator = RectBivariateSpline( np.log10(self.P_grid), self.T_grid, np.log10(abundances[species_name]), kx=1, ky=1) abund = 10**interpolator.ev(np.log10(P_profile), T_profile) atm_abundances[species_name] = abund mu_profile += abund * self.mass_data[species_name] radii, dr = _hydrostatic_solver._solve( P_profile, T_profile, self.ref_pressure, mu_profile, planet_mass, planet_radius, star_radius, above_cloud_cond, T_star) for key in atm_abundances: atm_abundances[key] = atm_abundances[key][above_cloud_cond] return radii, dr, atm_abundances, mu_profile
def get_subpixel(res): mgx, mgy = np.meshgrid(np.arange(-1, 1.01, 0.1), np.arange(-1, 1.01, 0.1), indexing='xy') # sub-pixel mesh minval, _, minloc, _ = cv2.minMaxLoc(res) rbs_halfsize = 3 # size of peak area used for spline for subpixel peak loc rbs_order = 4 # polynomial order for subpixel rbs interpolation of peak location if ((np.array([n - rbs_halfsize for n in minloc]) >= np.array([0, 0])).all() & (np.array([(n + rbs_halfsize) for n in minloc]) < np.array(list(res.shape))).all()): rbs_p = RBS( range(-rbs_halfsize, rbs_halfsize + 1), range(-rbs_halfsize, rbs_halfsize + 1), res[(minloc[1] - rbs_halfsize):(minloc[1] + rbs_halfsize + 1), (minloc[0] - rbs_halfsize):(minloc[0] + rbs_halfsize + 1)], kx=rbs_order, ky=rbs_order) b = rbs_p.ev(mgx.flatten(), mgy.flatten()) mml = cv2.minMaxLoc(b.reshape(21, 21)) # mgx,mgy: meshgrid x,y of common area # sp_delx,sp_dely: subpixel delx,dely sp_delx = mgx[mml[3][0], mml[3][1]] sp_dely = mgy[mml[3][0], mml[3][1]] else: sp_delx = 0.0 sp_dely = 0.0 return sp_delx, sp_dely
def imresize2D(im0, h0, dim): h0 = h0[0:2] dim = dim[0:2] # Image size dim0 = im0.shape # Create a regular grid x0, y0, x0lin, y0lin = gengrid.centered2D(dim0, h0) # Require the same FOV fov0 = dim0 * h0 # New voxelsize h = fov0 / dim # Create a regular grid where we want the new values x, y, xlin, ylin = gengrid.centered2D(dim, h) # Interpolation f = RectBivariateSpline(x0lin, y0lin, im0) x = x.flatten() y = y.flatten() # Must revert the order of x and y, otherwise its rotated im = f.ev(y, x).reshape(dim[0], dim[1]) return im
def _p(self, K, c): if self.params['use_interp']: data_path = os.path.join(os.path.dirname(__file__), 'data') data = np.load(os.path.join(data_path, "uKc_einasto.npz")) pk = data['pk'] _k = data['K'] _c = data['c'] c = np.atleast_1d(c) if np.isscalar(K): K = np.atleast_2d(K) if K.ndim < 2: if len(K) != len(c): K = np.atleast_2d(K).T # should be len(rs) x len(k) else: K = np.atleast_2d(K) pk[pk <= 0] = 1e-8 spl = RectBivariateSpline(np.log(_k), np.log(_c), np.log(pk)) cc = np.repeat(c, K.shape[0]) return np.exp( self._reduce( spl.ev(np.log(K.flatten()), np.log(cc)).reshape(K.shape))) else: #Numerical version. return super(Einasto, self)._p(K, c)
def test_spline_2d_outofbounds(self): x = np.array([.5, 2., 3., 4., 5.5]) y = np.array([.5, 2., 3., 4., 5.5]) z = np.array([[1, 2, 1, 2, 1], [1, 2, 1, 2, 1], [1, 2, 3, 2, 1], [1, 2, 2, 2, 1], [1, 2, 1, 2, 1]]) lut = RectBivariateSpline(x, y, z) xi = np.array([[1, 2.3, 6.3, 0.5, 3.3, 1.2, 3], [1, 3.3, 1.2, -4.0, 5.0, 1.0, 3]]).T actual = interpn((x, y), z, xi, method="splinef2d", bounds_error=False, fill_value=999.99) expected = lut.ev(xi[:, 0], xi[:, 1]) expected[2:4] = 999.99 assert_array_almost_equal(actual, expected) # no extrapolation for splinef2d assert_raises(ValueError, interpn, (x, y), z, xi, method="splinef2d", bounds_error=False, fill_value=None)
def correlate(image, pattern, include_direct_beam=False, sim_threshold=1e-5, interpolate=False, **kwargs): """The correlation between a diffraction pattern and a simulation. Calculated using .. math:: \frac{\sum_{j=1}^m P(x_j, y_j) T(x_j, y_j)}{\sqrt{\sum_{j=1}^m P^2(x_j, y_j)} \sqrt{\sum_{j=1}^m T^2(x_j, y_j)}} Parameters ---------- image : :class:`np.ndarray` A single electron diffraction signal. Should be appropriately scaled and centered. pattern : :class:`DiffractionSimulation` The pattern to compare to. sim_threshold : float The threshold simulation intensity to consider for correlation interpolate : bool If True, perform sub-pixel interpolation of the image. **kwargs Arguments to pass to scipy.interpolate.RectBivariateSpline Returns ------- float The correlation coefficient. References ---------- E. F. Rauch and L. Dupuy, “Rapid Diffraction Patterns identification through template matching,” vol. 50, no. 1, pp. 87–99, 2005. """ shape = image.shape half_shape = tuple(i // 2 for i in shape) pixel_coordinates = pattern.calibrated_coordinates.astype( int)[:, :2] + half_shape in_bounds = np.product( (pixel_coordinates > 0) * (pixel_coordinates < shape[0]), axis=1).astype(bool) pattern_intensities = pattern.intensities large_intensities = pattern_intensities > sim_threshold mask = np.logical_and(in_bounds, large_intensities) if interpolate: x = np.arange(shape[0], dtype='float') - half_shape[0] y = np.arange(shape[1], dtype='float') - half_shape[1] for ar, i in zip([x, y], shape): if not i % 2: ar += 0.5 x = x * pattern.calibration[0] y = y * pattern.calibration[1] ip = RectBivariateSpline(x, y, image.T, **kwargs) image_intensities = ip.ev(pattern.coordinates[:, 0][mask], pattern.coordinates[:, 1][mask]) else: image_intensities = image.T[pixel_coordinates[:, 0][in_bounds], pixel_coordinates[:, 1][in_bounds]] pattern_intensities = pattern_intensities[mask] return np.nan_to_num(_correlate(image_intensities, pattern_intensities))
def SubtractDominantMotion(image1, image2): # Input: # Images at time t and t+1 # Output: # mask: [nxm] # put your implementation here M = InverseCompositionAffine(image1, image2) tol = 0.35 h, w = image1.shape x = np.arange(w) y = np.arange(h) mask = np.ones((h, w), dtype=bool) x_temp = np.arange(0, w) y_temp = np.arange(0, h) xi, yi = np.meshgrid(x_temp, y_temp) ones = np.ones(w * h) xy1 = np.array([yi.flatten(), xi.flatten(), ones]) xy1_new = np.matmul(np.vstack((M, np.array([0, 0, 1]))), xy1) y_new = xy1_new[0, :] x_new = xy1_new[1, :] image2_spline = RectBivariateSpline(y, x, image2) temp = np.array(image2_spline.ev(y_new, x_new).tolist()) image1_new = np.reshape(temp, (h, w)) abs_diff = np.absolute(image1_new, image1) ind = (abs_diff >= tol) abs_diff[ind] = 1 abs_diff[~ind] = 0 mask = abs_diff return mask
def distort(image, center, angle, lengths): """Takes an image and distorts the image based on an elliptical distortion Parameters --------------- image: array-like The image to apply the elliptical distortion to center: list The center of the ellipse angle: float The angle of the major axis in radians lengths: The lengths of the major and minor axis of the ellipse Returns ------------ distorted:array-like The elliptically distorted image """ img_shape = np.shape(image) initial_y, initial_x = range(-center[1], img_shape[-2] - center[1]), range( -center[0], img_shape[-1] - center[0]) spline = RectBivariateSpline(initial_x, initial_y, image, kx=1, ky=1) xInd, yInd = cartesian_to_ellipse(center=center, angle=angle, lengths=lengths) distorted = np.array(spline.ev(yInd, xInd)) return distorted
def interpolate_grid(self, in_lon, in_lat): """ Interpolates MRMS data to a different grid using cubic bivariate splines """ out_data = np.zeros( (self.data.shape[0], in_lon.shape[0], in_lon.shape[1])) for d in range(self.data.shape[0]): print("Loading ", d, self.variable, self.start_date) if self.data[d].max() > -999: step = self.data[d] step[step < 0] = 0 if self.lat[-1] < self.lat[0]: spline = RectBivariateSpline(self.lat[::-1], self.lon, step[::-1], kx=3, ky=3) else: spline = RectBivariateSpline(self.lat, self.lon, step, kx=3, ky=3) print("Evaluating", d, self.variable, self.start_date) flat_data = spline.ev(in_lat.ravel(), in_lon.ravel()) out_data[d] = flat_data.reshape(in_lon.shape) del spline else: print(d, " is missing") out_data[d] = -9999 return out_data
def main(): basis = fits.open('basis.fits')[0].data aperture = fits.open('aperture.fits')[0].data name = sys.argv[1] size = basis.shape[1] size_ = int(sys.argv[2]) x_old_res = np.linspace(-size / 2, size / 2, size) y_old_res = np.linspace(-size / 2, size / 2, size) x_new_res = np.linspace(-size / 2, size / 2, size_) y_new_res = np.linspace(-size / 2, size / 2, size_) abscissae_lr, ordinates_lr = np.meshgrid(x_old_res, y_old_res) abscissae_nr, ordinates_nr = np.meshgrid(x_new_res, y_new_res) basis_new = np.zeros((basis.shape[0], size_, size_)) for i in range(basis.shape[0]): spline_basis_functions = RectBivariateSpline(x_old_res, y_old_res, basis[i]) basis_new[i] = spline_basis_functions.ev(ordinates_nr, abscissae_nr) * aperture writefits(basis_new, name)
def resample2d(i_data, i_s, i_e, i_i, o_s, o_e, o_i, kx=3, ky=3, s=0, gauss_sig=0, median_boxcar_size=0, clip=True): ''' Resample a square 2D input grid with extents defined by [i_s] and [i_e] with increment [i_i] to a new 2D grid with extents defined by [o_s] and [o_e] with increment [o_i]. Returns a 2D resampled array, with options for smoothing (gaussian and median) and clipping. ''' # calculate bivariate spline, G, using input grid and data grid_pre_rebin = np.arange(i_s, i_e, i_i) G = RectBivariateSpline(grid_pre_rebin, grid_pre_rebin, i_data, kx=kx, ky=ky) # evaluate this spline at new points on output grid grid_x, grid_y = np.mgrid[o_s:o_e:o_i, o_s:o_e:o_i] data = G.ev(grid_x, grid_y) if gauss_sig != 0: data = gaussian_filter(data, gauss_sig) if median_boxcar_size != 0: data = median_filter(data, median_boxcar_size) if clip: input_max = np.max(i_data) input_min = np.min(i_data) data[np.where(data>input_max)] = input_max data[np.where(data<input_min)] = input_min return data
def _interpolate_array(self, target) -> np.array: """ Interpolates SLSTR data arrays based on cartesian information contained within the sensor product using the RectBivariateSpline approach. Args: target: the product to be interpolated Returns: The interpolated data """ sat_zn = self.product['geometry_tn'][target][:] tx_x_var = self.product['cartesian_tx']['x_tx'][0, :] tx_y_var = self.product['cartesian_tx']['y_tx'][:, 0] an_x_var = self.product['cartesian_an']['x_an'][:] an_y_var = self.product['cartesian_an']['y_an'][:] spl = RectBivariateSpline(tx_y_var, tx_x_var[::-1], sat_zn[:, ::-1].filled(0)) interpolated = spl.ev(an_y_var.compressed(), an_x_var.compressed()) interpolated = np.ma.masked_invalid(interpolated, copy=False) sat = np.ma.empty(an_y_var.shape, dtype=sat_zn.dtype) sat[np.logical_not(np.ma.getmaskarray(an_y_var))] = interpolated sat.mask = an_y_var.mask return sat
def interpolate_individual(self, image): # unpacking ogridx, ogridy = self.ogrid ngridx, ngridy = self.ngrid f = RectBivariateSpline(ogridy, ogridx, image, kx=1, ky=1) return f.ev(ngridy.flatten(), ngridx.flatten()).reshape(ngridx.shape)
def LucasKanade(It, It1, rect, p0=np.zeros(2)): # Input: # It: template image # It1: Current image # rect: Current position of the car # (top left, bot right coordinates) # p0: Initial movement vector [dp_x0, dp_y0] # Output: # p: movement vector [dp_x, dp_y] # Put your implementation here p = p0 x1, y1, x2, y2 = rect[0], rect[1], rect[2], rect[3] threshold = 1e-3 dp = np.array([float("inf"), float("inf")]) interpolated_It = RectBivariateSpline( x=np.array([i for i in range(int(It.shape[0]))]), y=np.array([i for i in range(int(It.shape[1]))]), z=It) interpolated_It1 = RectBivariateSpline( x=np.array([i for i in range(int(It1.shape[0]))]), y=np.array([i for i in range(int(It1.shape[1]))]), z=It1) while np.sum(np.square(dp)) >= threshold: warp_x = np.arange(x1 + p[0], x2 + p[0] + .5) warp_y = np.arange(y1 + p[1], y2 + p[1] + .5) warp_X = np.array([warp_x for i in range(len(warp_y))]) warp_Y = np.array([warp_y for i in range(len(warp_x))]).T warp_It1x = interpolated_It1.ev(warp_Y, warp_X) x = np.arange(x1, x2 + .5) y = np.arange(y1, y2 + .5) X = np.array([x for i in range(len(y))]) Y = np.array([y for i in range(len(x))]).T Itx = interpolated_It.ev(Y, X) A = np.array([ interpolated_It1.ev(warp_Y, warp_X, dx=0, dy=1).flatten(), interpolated_It1.ev(warp_Y, warp_X, dx=1, dy=0).flatten() ]).T b = (Itx - warp_It1x).flatten() dp = np.dot(np.linalg.inv(np.dot(A.T, A)), np.dot(A.T, b)) p += dp return p
def InverseCompositionAffine(It, It1, threshold, num_iters): """ :param It: template image :param It1: Current image :param threshold: if the length of dp is smaller than the threshold, terminate the optimization :param num_iters: number of iterations of the optimization :return: M: the Affine warp matrix [3x3 numpy array] """ # put your implementation here M = np.eye(3) H0, W0 = It.shape H1, W1 = It1.shape It_interpolate = RectBivariateSpline(np.arange(0, H0, 1), np.arange(0, W0, 1), It) It1_interpolate = RectBivariateSpline(np.arange(0, H1, 1), np.arange(0, W1, 1), It1) # Gradient of warpped It x_warp, y_warp = np.meshgrid(np.arange(0, W0, 1), np.arange(0, H0, 1)) delta_I = np.array([It_interpolate.ev(y_warp, x_warp, dx=0, dy=1).flatten(), It_interpolate.ev(y_warp, x_warp, dx=1, dy=0).flatten()]).T A_origin = np.array([delta_I[:, 0] * x_warp.flatten(), delta_I[:, 0] * y_warp.flatten(), delta_I[:, 0], delta_I[:, 1] * x_warp.flatten(), delta_I[:, 1] * y_warp.flatten(), delta_I[:, 1]]).T for _ in range(int(num_iters)): # Warp It+1 x1, y1 = np.meshgrid(np.arange(0, W1, 1), np.arange(0, H1, 1)) x1_warp = M[0, 0] * x1 + M[0, 1] * y1 + M[0, 2] y1_warp = M[1, 0] * x1 + M[1, 1] * y1 + M[1, 2] # Only get common region for It and warpped It+1 overlap = (0 <= x1_warp) & (x1_warp < W1) & (0 <= y1_warp) & (y1_warp < H1) x1_warp = x1_warp[overlap] y1_warp = y1_warp[overlap] It1_warp = It1_interpolate.ev(y1_warp, x1_warp) A = A_origin[overlap.flatten()] b = It1_warp - It[overlap] delta_p = np.dot(np.dot(np.linalg.inv(np.dot(A.T, A)), A.T), b.flatten()) delta_M = np.concatenate((delta_p, np.array([0, 0, 1]))).reshape((3, 3)) delta_M[0, 0] += 1 delta_M[1, 1] += 1 M = np.dot(M, np.linalg.inv(delta_M)) if np.linalg.norm(delta_p) < threshold: break return M
def getStraightenWormInt(worm_img, skeleton, half_width = -1, cnt_widths = np.zeros(0), width_resampling = 7, ang_smooth_win = 12, length_resampling = 49): ''' Code to straighten the worm worms. worm_image - image containing the worm skeleton - worm skeleton half_width - half width of the worm, if it is -1 it would try to calculated from cnt_widths cnt_widths - contour widths used in case the half width is not given width_resampling - number of data points used in the intensity map along the worm width length_resampling - number of data points used in the intensity map along the worm length ang_smooth_win - window used to calculate the skeleton angles. A small value will introduce noise, therefore obtaining bad perpendicular segments. A large value will over smooth the skeleton, therefore not capturing the correct shape. ''' #if np.all(np.isnan(skeleton)): # buff = np.empty((skeleton.shape[0], width_resampling)) # buff.fill(np.nan) # return buff assert half_width>0 or cnt_widths.size>0 assert not np.any(np.isnan(skeleton)) if ang_smooth_win%2 == 1: ang_smooth_win += 1; if skeleton.shape[0] != length_resampling: skeleton, _ = curvspace(np.ascontiguousarray(skeleton), length_resampling) skelX = skeleton[:,0]; skelY = skeleton[:,1]; assert np.max(skelX) < worm_img.shape[0] assert np.max(skelY) < worm_img.shape[1] assert np.min(skelY) >= 0 assert np.min(skelY) >= 0 #calculate smoothed angles skel_angles = angleSmoothed(skelX, skelY, ang_smooth_win) #%get the perpendicular angles to define line scans (orientation doesn't #%matter here so subtracting pi/2 should always work) perp_angles = skel_angles - np.pi/2; #%for each skeleton point get the coordinates for two line scans: one in the #%positive direction along perpAngles and one in the negative direction (use #%two that both start on skeleton so that the intensities are the same in #%the line scan) #resample the points along the worm width if half_width <= 0: half_width = (np.median(cnt_widths[10:-10])/2.) #add half a pixel to get part of the contour r_ind = np.linspace(-half_width, half_width, width_resampling) #create the grid of points to be interpolated (make use of numpy implicit broadcasting Nx1 + 1xM = NxM) grid_x = skelX + r_ind[:, np.newaxis]*np.cos(perp_angles); grid_y = skelY + r_ind[:, np.newaxis]*np.sin(perp_angles); f = RectBivariateSpline(np.arange(worm_img.shape[0]), np.arange(worm_img.shape[1]), worm_img) return f.ev(grid_y, grid_x) #return interpolated intensity map
class SplineEstimator(object): def fit(self, x, y): self.lut = RectBivariateSpline(x[1], x[0], y) return self def predict(self, X): return self.lut.ev(X[:, 1], X[:, 0])
def getEroDep(self, xo = None, yo = None, xm = None, ym = None, pts = 100, gfilter = 5): """ Extract a slice from the 3D data set and compute its deposition thicknesses. Parameters ---------- variable: xo, yo Lower X,Y coordinates of the cross-section variable: xm, ym Upper X,Y coordinates of the cross-section variable: pts Number of points to discretise the cross-section variable: gfilter Gaussian smoothing filter """ if xm > self.x.max(): xm = self.x.max() if ym > self.y.max(): ym = self.y.max() if xo < self.x.min(): xo = self.x.min() if yo < self.y.min(): yo = self.y.min() xsec, ysec = self._cross_section(xo, yo, xm, ym, pts) self.dist = np.sqrt(( xsec - xo )**2 + ( ysec - yo )**2) # Surface rect_B_spline = RectBivariateSpline(self.y[:,0], self.x[0,:], self.z) datatop = rect_B_spline.ev(ysec, xsec) self.top = filters.gaussian_filter1d(datatop,sigma=gfilter) # Cumchange rect_B_spline = RectBivariateSpline(self.y[:,0], self.x[0,:], self.cumchange) cumdat = rect_B_spline.ev(ysec, xsec) gcum = filters.gaussian_filter1d(cumdat,sigma=gfilter) self.depo = gcum.clip(min=0) return
def __init__(self, R_in, z_in, Raxis, zaxis, psi_in, R_out, z_out, psi_sep=0): print('2d interp') self.error = 0 # Check input dimensions, R_out z_out must be flat if len(R_out) != len(z_out): print('R and z must have the same dimensions') self.error = 1 return if np.array(R_out).ndim > 1: print('R_out must be flat') self.error = 2 return if np.array(z_out).ndim > 1: print('z_out must be flat') self.error = 3 return nz_psi, nR_psi = psi_in.shape if len(R_in) != nR_psi: print('Inconsistent R axis for psi_in') self.error = 5 return if len(z_in) != nz_psi: print('Inconsistent z axis for psi_in') self.error = 6 return nRz = len(R_out) self.psi_red = np.zeros(nRz) # Bilinear interpolation bisp = RectBivariateSpline(z_in, R_in, psi_in) self.psi_axis = bisp.ev(zaxis, Raxis) for jRz, R in enumerate(R_out): z = z_out[jRz] self.psi_red[jRz] = bisp.ev(z, R) self.psi_norm = (self.psi_red - self.psi_axis)/(psi_sep - self.psi_axis) self.rho_pol = np.sqrt(self.psi_norm)
def assign_phases_to_antennas(ant1,ant2,antX,antY,PhaseGrid,phase_x,phase_y,velocity,time): ''' Given antenna IDs, coordinates, and the phase grid and its coordinates: Translate the antennas across the grid and record the phase for each antenna. Returns a 1D array of antenna phases (uncalibrated) for the 1st and 2nd antenna in each observation ''' f_interp = RectBivariateSpline(phase_y,phase_x,PhaseGrid,kx=1,ky=1) antenna1_phase = f_interp.ev(antY[ant1],antX[ant1]+velocity*time) antenna2_phase = f_interp.ev(antY[ant2],antX[ant2]+velocity*time) # Also want to get a 2d array of the phase of each antenna with time, to ease with calibration Ntsteps = len(time)/(len(antX)*(len(antX)-1)/2) antennaphases = np.zeros([len(antX),Ntsteps],float) tstepsize = np.unique(time)[1]-np.unique(time[0]) for i in range(len(antX)): antennaphases[i,:] = f_interp.ev(antY[i]*np.ones(Ntsteps),antX[i]+tstepsize*velocity*np.arange(Ntsteps)) return antenna1_phase,antenna2_phase,antennaphases
def scatter(self,move_pix=0,scale=1): ''' Generate the scattered image which is stored in the ``iss`` member. :param move_pix: (optional) int Number of pixels to roll the screen (for time evolution). :param scale: (optional) scalar Scale factor for gradient. To simulate the scattering effect at another wavelength this is (lambda_new/lambda_old)**2 ''' M = self.model.shape[-1] # size of original image array N = self.nx # size of output image array #if not self.live_dangerously: self._checkSanity() # calculate phase gradient dphi_x,dphi_y = self._calculate_dphi(move_pix=move_pix) if scale != 1: dphi_x *= scale/sqrt(2.) dphi_y *= scale/sqrt(2.) xx_,yy = np.meshgrid((np.arange(N) - 0.5*(N-1)),\ (np.arange(N) - 0.5*(N-1)),indexing='xy') # check whether we care about PA of scattering kernel if self.pa != None: f_model = RectBivariateSpline(self.model_dx/self.dx*(np.arange(M) - 0.5*(M-1)),\ self.model_dx/self.dx*(np.arange(M) - 0.5*(M-1)),\ self.model) # apply rotation theta = -(90 * pi / 180) + np.radians(self.pa) # rotate CW 90 deg, then CCW by PA xx_ += dphi_x yy += dphi_y xx = cos(theta)*xx_ - sin(theta)*yy yy = sin(theta)*xx_ + cos(theta)*yy self.iss = f_model.ev(yy.flatten(),xx.flatten()).reshape((self.nx,self.nx)) # rotate back and clip for positive values for I if self.think_positive: self.iss = clip(rotate(self.iss,-1*theta/np.pi*180,reshape=False),a_min=0,a_max=1e30) * (self.dx/self.model_dx)**2 else: self.iss = rotate(self.iss,-1*theta/np.pi*180,reshape=False) * (self.dx/self.model_dx)**2 # otherwise do a faster lookup rather than the expensive interpolation. else: yyi = np.rint((yy+dphi_y+self.nx/2)).astype(np.int) % self.nx xxi = np.rint((xx_+dphi_x+self.nx/2)).astype(np.int) % self.nx if self.think_positive: self.iss = clip(self.isrc[yyi,xxi],a_min=0,a_max=1e30) else: self.iss = self.isrc[yyi,xxi]
def x_sig( self, x, sigma ): eps_list, mu_q = self.spirrid_response eps_sig = InterpolatedUnivariateSpline( mu_q[0, :], eps_list[1] ) if max( mu_q ) > sigma: pass else: raise ValueError( 'applied stress higher than the maximum in micromechanical evaluation of a CB' ) eps = eps_sig( sigma ) spline = RectBivariateSpline( eps_list[0], eps_list[1], mu_q ) sigma_f = spline.ev( x, ones( len( x ) ) * eps ) / self.V_f sigma_m = ( sigma - sigma_f * self.V_f ) / self.V_m return sigma_m
def kde_histogram(events_x, events_y, xout=None, yout=None, bins=None): """ Histogram-based Kernel Density Estimation Parameters ---------- events_x, events_y: 1D ndarray The input points for kernel density estimation. Input is flattened automatically. xout, yout: ndarray The coordinates at which the KDE should be computed. If set to none, input coordinates are used. bins: tuple (binsx, binsy) The number of bins to use for the histogram. Returns ------- density: ndarray, same shape as `xout` The KDE for the points in (xout, yout) See Also -------- `numpy.histogram2d` `scipy.interpolate.RectBivariateSpline` """ valid_combi = ((xout is None and yout is None) or (xout is not None and yout is not None) ) if not valid_combi: raise ValueError("Both `xout` and `yout` must be (un)set.") if yout is None and yout is None: xout = events_x yout = events_y if bins is None: bins = (max(5, bin_num_doane(events_x)), max(5, bin_num_doane(events_y))) # Compute the histogram hist2d, xedges, yedges = np.histogram2d(x=events_x, y=events_y, bins=bins, normed=True) xip = xedges[1:]-(xedges[1]-xedges[0])/2 yip = yedges[1:]-(yedges[1]-yedges[0])/2 estimator = RectBivariateSpline(x=xip, y=yip, z=hist2d) density = estimator.ev(xout, yout) density[density < 0] = 0 return density.reshape(xout.shape)
def add_dem_2D(self, x, dem, y0=0., y1=np.infty, yref=None, kx=3, ky=1, s=None): ''' Add topography by vertically stretching the domain in the region [y0, y1] - points below y0 are kept fixed, points above y1 are moved as the DEM, points in between are interpolated. Usage: first call add_dem_2D for each boundary that is to be perturbed and finally call apply_dem to add the perturbation to the mesh coordinates. :param x: x coordinates of the DEM :type x: numpy array :param dem: the DEM :type dem: numpy array :param y0: vertical coordinate, at which the stretching begins :type y0: float :param y1: vertical coordinate, at which the stretching ends, can be infinity :type y1: float :param yref: vertical coordinate, at which the stretching ends :type yref: float :param kx: horizontal degree of the spline interpolation :type kx: integer :param ky: vertical degree of the spline interpolation :type ky: integer :param s: smoothing factor :type s: float ''' if not self.ndim == 2: # pragma: no cover raise ValueError('apply_dem_2D works on 2D meshes only') if yref is None: yref = self.points[:, 1].max() if y1 < np.infty: y = np.array([y0, yref, y1]) d = np.c_[np.zeros(len(dem)), dem, np.zeros(len(dem))] else: y = np.array([y0, yref]) d = np.c_[np.zeros(len(dem)), dem] xx, yy = np.meshgrid(x, y, indexing='ij') rbs = RectBivariateSpline(x, y, d, kx=kx, ky=ky, s=s) # add to topography if self.topography is None: self.topography = np.zeros_like(self.points[:, -1]) self.points[:, 1] += rbs.ev(self.points[:, 0], self.points[:, 1])
def fft_interpolate(visdata,immap,xmap,ymap,ug=None,scaleamp=1.,shiftphase=[0.,0.]): """ Take a dataset and a map of a field, fft the image, and interpolate onto the uv-coordinates of the dataset. Returns: interpdata: Visdata object A dataset which samples the given immap """ # Correct for PB attenuation if visdata.PBfwhm is not None: PBs = visdata.PBfwhm / (2.*np.sqrt(2.*np.log(2))) immap *= np.exp(-(xmap**2./(2.*PBs**2.)) - (ymap**2./(2.*PBs**2.))) #immap = immap[::-1,:] # Fixes issue of origin in tlc vs blc to match sky coords imfft = fftshift(fft2(fftshift(immap))) # Calculate the uv points we need, if we don't already have them if ug is None: kmax = 0.5/((xmap[0,1]-xmap[0,0])*arcsec2rad) ug = np.linspace(-kmax,kmax,xmap.shape[0]) # Interpolate the FFT'd image onto the data's uv points # Using RBS, much faster since ug is gridded spliner = RectBivariateSpline(ug,ug,imfft.real,kx=1,ky=1) splinei = RectBivariateSpline(ug,ug,imfft.imag,kx=1,ky=1) interpr = spliner.ev(visdata.v,visdata.u) interpi = splinei.ev(visdata.v,visdata.u) interpdata = Visdata(visdata.u,visdata.v,interpr,interpi,visdata.sigma,\ visdata.ant1,visdata.ant2,visdata.PBfwhm,'interpolated_data') # Apply scaling, phase shifts; wrap phases to +/- pi. interpdata.amp *= scaleamp interpdata.phase += 2.*np.pi*arcsec2rad*(shiftphase[0]*interpdata.u + shiftphase[1]*interpdata.v) interpdata.phase = (interpdata.phase + np.pi) % (2*np.pi) - np.pi return interpdata
def _interp(self): """Interpolate the cartesian coordinates. """ if np.all(self.hrow_indices == self.row_indices): return self._interp1d() xpoints, ypoints = np.meshgrid(self.hrow_indices, self.hcol_indices) spl = RectBivariateSpline(self.row_indices, self.col_indices, self.x__, s=0, kx=self.kx_, ky=self.ky_) self.newx = spl.ev(xpoints.ravel(), ypoints.ravel()) self.newx = self.newx.reshape(xpoints.shape).T spl = RectBivariateSpline(self.row_indices, self.col_indices, self.y__, s=0, kx=self.kx_, ky=self.ky_) self.newy = spl.ev(xpoints.ravel(), ypoints.ravel()) self.newy = self.newy.reshape(xpoints.shape).T spl = RectBivariateSpline(self.row_indices, self.col_indices, self.z__, s=0, kx=self.kx_, ky=self.ky_) self.newz = spl.ev(xpoints.ravel(), ypoints.ravel()) self.newz = self.newz.reshape(xpoints.shape).T
def run_slimscat(isrc,idx,screenfile='screen.bin'): ''' Scatter source image. :param isrc: source image :param idx: source pixel scale :param screenfile: screen file ''' # read in screen parameters f = open(screenfile,'rb') hdrsize = struct.unpack('i',f.read(4))[0] nphi = int(np.sqrt(struct.unpack('i',f.read(4))[0])) dx = struct.unpack('d',f.read(8))[0] f.seek(hdrsize) # filter image # check fov iny,inx = isrc.shape ny = int(np.floor(iny*idx/dx)) nx = int(np.floor(inx*idx/dx)) assert idx*max([iny,inx]) < nphi*dx # read in screen dphi_x = np.empty((ny,nx),dtype=np.float64) dphi_y = np.empty((ny,nx),dtype=np.float64) for i in range(ny): f.seek(hdrsize + i*8*1*nphi,0) dphi_x[i,:] = struct.unpack('{0:d}d'.format(nx),f.read(nx*8)) for i in range(ny): f.seek(hdrsize + 8*nphi*nphi + i*8*1*nphi,0) dphi_y[i,:] = struct.unpack('{0:d}d'.format(nx),f.read(nx*8)) f.close() # construct spline fit to source image f_isrc = RectBivariateSpline(idx/dx*(np.arange(iny) - 0.5*(iny-1)),\ idx/dx*(np.arange(inx) - 0.5*(inx-1)),\ isrc) # scatter pixel coordinates yy,_xx = np.meshgrid((np.arange(ny) - 0.5*(ny-1)),\ (np.arange(nx) - 0.5*(nx-1)),indexing='ij') _xx += dphi_x yy += dphi_y return f_isrc.ev(yy.flatten(),_xx.flatten()).reshape((ny,nx))
def get_interpolated_pixel_color_rbspline(pts, s_im, size): """given pts in floats, linear interpolate pixel values nearby to get a good colour""" pts = clamp(pts, size) s_im = np.atleast_3d(s_im) ys,xs = size ycoords, xcoords = np.arange(ys), np.arange(xs) out = np.empty(pts.shape[1:] + (s_im.shape[-1],),dtype=s_im.dtype) pts_vec = pts.reshape((2,-1)) out_vec = out.reshape((-1,s_im.shape[-1])) #flatten for easier vectorization for i in range(s_im.shape[-1]): #loop over color channels rbspline = RectBivariateSpline(ycoords, xcoords, s_im[...,i]) out_vec[:,i] = rbspline.ev(pts_vec[0],pts_vec[1]) return out
def interp3d_emergence(uplift, data, out_times, verbose=False): """Interpolate uplift surfaces (xyz data at a specific t) to data locations (non-grid) and data times (between times calculated). Uses progressive linear interpolations: first the uplift at each outputted time is interpolated to the data locations in data.locs, then they are interpolated to the data times in each location. Parameters ---------- uplift (array-like) - size (times, lon, lat) array of uplift surfaces data - data whose data.locs are the locations to interpolate to. out_times - the times for the first index of the uplift array (should be of uplift eventually, yes?) """ time_start = time.clock() ########################################## # STUFF TO FIX HEEEEEEERE!!!!!!!!!!!!! N = uplift[0].shape # TODO These should be gotten from somewhere, right? uplift.grid?? X = np.linspace(0, 4900000, num=N[1], endpoint=True) Y = np.linspace(0, 4700000, num=N[0], endpoint=True) ########################################## # interp_data will be an array of size (N_output_times, N_locations) # for use in interpolating the calculated emergence to the locations and # times at which there are data in data interp_data = [] # Interpolate the calculated uplift at each time on the Lat-Lon grid # to the data locations. for uplift_at_a_time in uplift: interp_func = RectBivariateSpline(X, Y, uplift_at_a_time.T) interp_data.append(interp_func.ev(data.locs[:,0], data.locs[:,1])) interp_data = np.array(interp_data).T calc_vector = [] # Interpolate the calculated uplifted at each time and data location # to the times of the data location. for interp, loc in zip(interp_data, data): calc_vector.append(np.interp(loc['data_dict']['times'], out_times[::-1], interp[::-1])) # flatten the array calc_vector = np.array([item for l in calc_vector for item in l]) if verbose: print 'Interpolation time: {0}s'.format(time.clock()-time_start) return calc_vector
def project_interp(self,to_file=None,sys_a8=False,bok=True,clobber=False,**kwd): # projected image x,y to_nx,to_ny=self.to_size print('get XY in image for pixels in new WCS ...') xx,yy=np.meshgrid(np.arange(to_nx),np.arange(to_ny)) # projected image ra dec ra,dec=self.to_wcs.all_pix2world(xx,yy,0) # image XY if sys_a8: imxx,imyy=a8.a8_ad2xy(self.head,ra,dec,bok=bok) imxx-=1.0 imyy-=1.0 else: imxx,imyy=self.wcs.all_world2pix(ra,dec,0) data=self.data.copy() ny,nx=self.data.shape inmask=(imyy > -0.5) & (imyy < ny-0.5) & (imxx > -0.5) & (imxx < nx-0.5) if not inmask.any(): return None,None int_data=np.zeros((to_ny,to_nx)) if self.mask is not None: int_mask=np.zeros((to_ny,to_nx),dtype='bool') indr,indc=np.where(inmask) tmpyy=np.round(imyy[inmask]).astype('int') tmpxx=np.round(imxx[inmask]).astype('int') tmpmask=self.mask[tmpyy,tmpxx] int_mask[indr,indc]=tmpmask int_mask[np.logical_not(inmask)]=True print('project image to new WCS by interpolating ...') ff=RectBivariateSpline(np.arange(ny),np.arange(nx),data,**kwd) inmaskval=ff.ev(imyy[inmask],imxx[inmask]) #int_data[np.logical_not(inmask)]=np.nan int_data[inmask]=inmaskval if to_file is not None: hdu=self.to_wcs.to_fits()[0] hdu.data=int_data hdu.writeto(to_file,clobber=clobber) if self.mask is not None: f,ext=os.path.splitext(to_file) hdu.data=int_mask.astype('uint8') hdu.writeto(f+'-mask.fits',clobber=clobber) if self.mask is not None: return int_data,int_mask else: return int_data,None
def generate_score_map(structure): if structure == 'BackG': return None score_matrix = np.zeros((n_sample_x, n_sample_y)) score_matrix[sample_location_indices[:,0], sample_location_indices[:,1]] = probs_allClasses[structure] spline = RectBivariateSpline(sample_locations_unique_xs/shrink_factor, sample_locations_unique_ys/shrink_factor, score_matrix, bbox=[interpolation_xmin/shrink_factor, interpolation_xmax/shrink_factor, interpolation_ymin/shrink_factor, interpolation_ymax/shrink_factor]) t1 = time.time() dense_score_map = spline.ev(sample_locations_interpolatedArea_xs_matrix, sample_locations_interpolatedArea_ys_matrix) sys.stderr.write('evaluate spline: %.2f seconds\n' % (time.time() - t1)) # 5s for shrink_factor=4; doubling results in quadratic time reduction t1 = time.time() dense_score_map = resize(dense_score_map, (interpolation_h, interpolation_w)) # similar speed as rescale # dense_score_map = rescale(dense_score_map, shrink_factor) sys.stderr.write('scale up: %.2f seconds\n' % (time.time() - t1)) # 10s, very high penalty when multiprocessing # t = time.time() dense_score_map[dense_score_map < 1e-1] = 0 dense_score_map[dense_score_map > 1.] = 1. # sys.stderr.write('threshold: %.2f seconds\n' % (time.time() - t)) if np.count_nonzero(dense_score_map) < 1e5: sys.stderr.write('No %s is detected on section %d\n' % (structure, sec)) return None t1 = time.time() scoremap_bp_filepath, scoremap_interpBox_filepath = \ DataManager.get_scoremap_filepath(stack=stack, fn=fn, anchor_fn=anchor_fn, structure=structure, return_bbox_fp=True, setting=actual_setting) save_hdf(dense_score_map.astype(np.float16), scoremap_bp_filepath, complevel=5) np.savetxt(scoremap_interpBox_filepath, np.array((interpolation_xmin, interpolation_xmax, interpolation_ymin, interpolation_ymax))[None], fmt='%d') sys.stderr.write('save: %.2f seconds\n' % (time.time() - t1)) # 4s, very high penalty when multiprocessing
def getStraightenWormIntT(worm_img, skeleton, half_width = -1, cnt_widths = np.zeros(0), width_resampling = 7, ang_smooth_win = 12, length_resampling = 49): #if np.all(np.isnan(skeleton)): # buff = np.empty((skeleton.shape[0], width_resampling)) # buff.fill(np.nan) # return buff assert half_width>0 or cnt_widths.size>0 assert not np.any(np.isnan(skeleton)) if ang_smooth_win%2 == 1: ang_smooth_win += 1; if skeleton.shape[0] != length_resampling: skeleton, _ = curvspace(np.ascontiguousarray(skeleton), length_resampling) skelX = skeleton[:,0]; skelY = skeleton[:,1]; assert np.max(skelX) < worm_img.shape[0] assert np.max(skelY) < worm_img.shape[1] assert np.min(skelY) >= 0 assert np.min(skelY) >= 0 #calculate smoothed angles skel_angles = angleSmoothed(skelX, skelY, ang_smooth_win) #%get the perpendicular angles to define line scans (orientation doesn't #%matter here so subtracting pi/2 should always work) perp_angles = skel_angles - np.pi/2; #%for each skeleton point get the coordinates for two line scans: one in the #%positive direction along perpAngles and one in the negative direction (use #%two that both start on skeleton so that the intensities are the same in #%the line scan) #resample the points along the worm width if half_width <= 0: half_width = (np.median(cnt_widths[10:-10])/2.) #add half a pixel to get part of the contour r_ind = np.linspace(-half_width, half_width, width_resampling) #create the grid of points to be interpolated (make use of numpy implicit broadcasting Nx1 + 1xM = NxM) grid_x = skelX + r_ind[:, np.newaxis]*np.cos(perp_angles); grid_y = skelY + r_ind[:, np.newaxis]*np.sin(perp_angles); f = RectBivariateSpline(np.arange(worm_img.shape[0]), np.arange(worm_img.shape[1]), worm_img) return f.ev(grid_y, grid_x), grid_x, grid_y #return interpolated intensity map
def find_stop_power(**kwargs): data = TRS398_table7() stop_power_interp = RectBivariateSpline( np.array(data["depth/R50"]), np.array(data["R50"]), np.array(data["contents"]) ) energy = kwargs["energy"] depth_mm = np.array(kwargs["depth"]) depth_cm = depth_mm / 10 R50_mm = energy_to_R50(energy) R50_cm = R50_mm / 10 depth_over_R50 = depth_cm / R50_cm stop_power = np.ravel(stop_power_interp.ev(depth_over_R50, R50_cm)) return stop_power
def getStraightenWormInt(worm_img, skeleton, half_width, width_resampling): ''' Code to straighten the worm worms. worm_image - image containing the worm skeleton - worm skeleton half_width - half width of the worm, if it is -1 it would try to calculated from cnt_widths cnt_widths - contour widths used in case the half width is not given width_resampling - number of data points used in the intensity map along the worm width length_resampling - number of data points used in the intensity map along the worm length ang_smooth_win - window used to calculate the skeleton angles. A small value will introduce noise, therefore obtaining bad perpendicular segments. A large value will over smooth the skeleton, therefore not capturing the correct shape. ''' assert half_width>0 or cnt_widths.size>0 assert not np.any(np.isnan(skeleton)) dX = np.diff(skeleton[:,0]) dY = np.diff(skeleton[:,1]) skel_angles = np.arctan2(dY, dX) skel_angles = np.hstack((skel_angles[0], skel_angles)) #%get the perpendicular angles to define line scans (orientation doesn't #%matter here so subtracting pi/2 should always work) perp_angles = skel_angles - np.pi/2; #%for each skeleton point get the coordinates for two line scans: one in the #%positive direction along perpAngles and one in the negative direction (use #%two that both start on skeleton so that the intensities are the same in #%the line scan) r_ind = np.linspace(-half_width, half_width, width_resampling) #create the grid of points to be interpolated (make use of numpy implicit broadcasting Nx1 + 1xM = NxM) grid_x = skeleton[:,0] + r_ind[:, np.newaxis]*np.cos(perp_angles); grid_y = skeleton[:,1] + r_ind[:, np.newaxis]*np.sin(perp_angles); #interpolated the intensity map f = RectBivariateSpline(np.arange(worm_img.shape[0]), np.arange(worm_img.shape[1]), worm_img) straighten_worm = f.ev(grid_y, grid_x) return straighten_worm, grid_x, grid_y
def _interp(self): """Interpolate the cartesian coordinates. """ if np.all(self.hrow_indices == self.row_indices): return self._interp1d() xpoints, ypoints = np.meshgrid(self.hrow_indices, self.hcol_indices) for num, data in enumerate(self.tie_data): spl = RectBivariateSpline(self.row_indices, self.col_indices, data, s=0, kx=self.kx_, ky=self.ky_) self.new_data[num] = spl.ev(xpoints.ravel(), ypoints.ravel()) self.new_data[num] = self.new_data[num].reshape(xpoints.shape).T
def interp_tilt(uplift, data, out_times, basemap, verbose=False): time_start = time.clock() ########################################## # STUFF TO FIX HEEEEEEERE!!!!!!!!!!!!! N = uplift[0].shape # TODO These should be gotten from somewhere, right? uplift.grid?? X = np.linspace(0, 4900000, num=N[1], endpoint=True) Y = np.linspace(0, 4700000, num=N[0], endpoint=True) ########################################## Lon, Lat = basemap(*np.meshgrid(X, Y), inverse=True) tilt = calc_tilts(uplift[np.where(out_times==13)[0][0]], Lon, Lat) interp_func = RectBivariateSpline(X, Y, tilt.T) calc_vector = interp_func.ev(data.locs[:,0], data.locs[:,1]) return calc_vector
def optpath_scipyode(xs, ys, tt, phi, startpoint): # setting up interpolation tt_interp=RectBivariateSpline(xs,ys,tt.T) phi_interp=RectBivariateSpline(xs,ys,phi.T) # initial condition t0 = 0.0 y0 = startpoint signorigphi=np.asscalar(phi_interp.ev(y0[0],y0[1])) # trajectory ts = [] ys = [] # for trajectory and aborting condition def solout(t, y): # time of the solver is not time in the problem... ts.append(tt_interp.ev(y[0],y[1])) ys.append(y.copy()) if not signorigphi*np.asscalar(phi_interp.ev(y0[0],y0[1]))>0: return -1 else: return 0 # rhs of ODE def rhs(t, y): gradx=tt_interp.ev(y[0],y[1],dx=1,dy=0) grady=tt_interp.ev(y[0],y[1],dx=0,dy=1) auxgrad=math.sqrt(gradx*gradx+grady*grady) return [-gradx/auxgrad, -grady/auxgrad] # the actual integration ig = ode(rhs).set_integrator('dopri5') ig.set_initial_value(y0, t0) ig.set_solout(solout) # throws a warning at the moment... ret = ig.integrate(1.0e8) # what an ugly hack to make a proper np array... npts=np.asarray(ts) npts.resize((len(ts),1)) npys=np.asarray(ys) return np.concatenate((npts,npys),axis=1)