def advect_once(self, dt): stime_calc = compute_ptimer_hr() fdt = self._ft[1] - self._ft[0] if type(fdt) is not numpy.float64: fdt = timedelta(fdt).total_seconds() etime_calc = compute_ptimer_hr() self._compute_time += (etime_calc - stime_calc) x = [] y = [] t = [] stime_mem = compute_ptimer_hr() for p in self._data: x.append(p.pt[0]) y.append(p.pt[1]) t.append(p.pt[2]) pts = (numpy.array(t), numpy.array(y), numpy.array(x)) etime_mem = compute_ptimer_hr() self._io_mem_time += (etime_mem - stime_mem) stime_calc = compute_ptimer_hr() us = interpn(self._gdims, self._fu, pts, method='linear', fill_value=.0) vs = interpn(self._gdims, self._fv, pts, method='linear', fill_value=.0) for i, p in enumerate(self._data): # p.advect(self._fu, self._fv, self._gdims, dt, fdt) p.advect_uv(us[i], vs[i], self._gdims, dt, fdt) self._simtime += dt etime_calc = compute_ptimer_hr() self._compute_time += (etime_calc - stime_calc)
def interpolate_complex_slice_2d(x, y, dfl_slice, dgrid): """ Interpolates 2d complex fld/dfl array at points Input x: list of x points to interpolate at y: list of y points to interpolate at dfl_slice: complex field grid in 2d (ncar, ncar) dgrid: extent of field grid from [-dgrid, dgrid] in x and y Output: complex field at points """ dat = dfl_slice nx = len(dat) # = ncar dx = 2 * dgrid / (nx - 1) xmin = -dgrid xlist = [dx * i + xmin for i in range(nx)] # interpn only works on real data. Two calls xylist = np.transpose([x, y]) redat = interpn((xlist, xlist), np.real(dat), xylist) imdat = interpn((xlist, xlist), np.imag(dat), xylist) # rejoin complex number return 1j * imdat + redat
def mapped_weight(u, y, x, ttT, xxT, i): # Same as 'mapped' function, but also return weight from interpolation # Used in the computation of the derivative of the cost function ny = len(y) nx = len(x) yc = np.linspace(0, ny - 1, (2**i + 1), dtype=int) xc = np.linspace(0, nx - 1, (2**i + 1), dtype=int) xx, tt = np.meshgrid(x, y, indexing='ij') # Transform coordinate Tt = interpolate.interpn((x[xc], y[yc]), ttT, np.array([xx.reshape(-1), tt.reshape(-1)]).T, method='linear') Tx = interpolate.interpn((x[xc], y[yc]), xxT, np.array([xx.reshape(-1), tt.reshape(-1)]).T, method='linear') # Interpolated function uT, uT_x, uT_y = interpn_linear((x, y), u, np.array([Tx, Tt]).T, method='linear', bounds_error=False, fill_value=0) # ,fill_value=1000) return uT.reshape(nx, ny), uT_x, uT_y
def mapped_TAHMO(u, y, x, yyT, xxT, lat_sta, lon_sta, i): # Return the values of the warped signal at given coordinates (lat_sta,lon_sta) ny = len(y) nx = len(x) yc = np.linspace(0, ny - 1, (2**i + 1), dtype=int) xc = np.linspace(0, nx - 1, (2**i + 1), dtype=int) # Transform coordinate Tt = interpolate.interpn((x[xc], y[yc]), yyT, np.array([lon_sta, lat_sta]).T, method='linear', bounds_error=False, fill_value=None) Tx = interpolate.interpn((x[xc], y[yc]), xxT, np.array([lon_sta, lat_sta]).T, method='linear', bounds_error=False, fill_value=None) # Interpolated function uT = interpolate.interpn((x, y), u, np.array([Tx, Tt]).T, method='linear', bounds_error=False, fill_value=None) # ,fill_value=1000) return uT
def get_uv_wind(self, lon, lat, idx): """ Consult https://docs.scipy.org/doc/scipy-0.18.1/reference/generated/scipy.interpolate.interpn.html :param lon: longitude of the point :param lat: latitude of the point :param idx: idx in the grib file (see physical_time_to_idx) :return: -- interpolated -- (u, v) wind conditions at (lon, lat) point, for the corresponding 'idx' """ # find out idx relatively to physical time giv idx = idx u10 = self.gribs[idx, 0, :, :] v10 = self.gribs[idx, 1, :, :] interpolated_value_uwind = interpolate.interpn( points=(self.latitudes[:, 0], self.longitudes[0, :]), values=u10, xi=([lat], [lon]), method="linear") interpolated_value_vwind = interpolate.interpn( points=(self.latitudes[:, 0], self.longitudes[0, :]), values=v10, xi=([lat], [lon]), method="linear") return interpolated_value_uwind, interpolated_value_vwind
def aero_model(alpha, bet, VT, h, eta, P, Q, R, dela, dele, delr): eta1 = eta[0, 0] eta2 = eta[1, 0] # trimming alp_trm = min(max(min(alp_grd), alpha), max(alp_grd)) dele_trm = min(max(min(dele_grd), dele), max(dele_grd)) eta1_trm = min(max(min(eta1_grd), eta1), max(eta1_grd)) eta2_trm = min(max(min(eta2_grd), eta2), max(eta2_grd)) # longitudinal coefficient interpolation CD = interpn((alp_grd, dele_grd, eta1_grd, eta2_grd), CD_grd, (alp_trm, dele_trm, eta1_trm, eta2_trm)) CL = interpn((alp_grd, dele_grd, eta1_grd, eta2_grd), CL_grd, (alp_trm, dele_trm, eta1_trm, eta2_trm)) Cm = interpn((alp_grd, dele_grd, eta1_grd, eta2_grd), Cm_grd, (alp_trm, dele_trm, eta1_trm, eta2_trm)) # lateral coefficient CC = 0 Cl = 0 Cn = 0 # coordinate change from wind to body CX = m.cos(alpha) * m.cos(bet) * (-CD) - m.cos(alpha) * m.sin(bet) * ( -CC) - m.sin(alpha) * (-CL) CY = m.sin(bet) * (-CD) + m.cos(bet) * (-CC) + 0 * (-CL) CZ = m.cos(bet) * m.sin(alpha) * (-CD) - m.sin(alpha) * m.sin(bet) * ( -CC) + m.cos(alpha) * (-CL) return CX, CY, CZ, Cl, Cm, Cn, CL, CD
def getPointValue(phys_state, x1, x2, x3, field='velocity'): assert (phys_state.geometry == 'shell' ), "Tools not implemented for geometry" + phys_state.geometry # find the grid in radial and meridional direction x1_grid = phys_state.grid_r[::-1] x2_grid = phys_state.grid_theta[::-1] x3_grid = phys_state.grid_phi fields = field_storage[field] Field1 = interpn((x1_grid, x2_grid, x3_grid), getattr(phys_state.fields, fields + '_r')[::-1, ::-1, :], (x1, x2, x3)) Field2 = interpn((x1_grid, x2_grid, x3_grid), getattr(phys_state.fields, fields + '_theta')[::-1, ::-1, :], (x1, x2, x3)) Field3 = interpn((x1_grid, x2_grid, x3_grid), getattr(phys_state.fields, fields + '_phi')[::-1, ::-1, :], (x1, x2, x3)) fieldp = field_presentation[field] result = { 'r': x1, 'theta': x2, 'phi': x3, fieldp + 'R': Field1.T, fieldp + 'Theta': Field2.T, fieldp + 'Phi': Field3.T } return result
def probe_data(self, rad, lat, lon, **kwargs): ''' returns the value of the field at the point specified. params: lat lon depth ''' type = kwargs.get('type', 'point') if type == 'cell': p1 = self.rad[0:len(self.rad) - 1] p2 = self.lat[0:len(self.lat) - 1] p3 = self.lon[0:len(self.lon) - 1] return interpn(points=(p1, p2, p3), values=self.data, xi=(rad, lat, lon), bounds_error=False, fill_value=0.0) elif type == 'point': return interpn(points=(self.rad, self.lat, self.lon), values=self.data_pts, xi=(rad, lat, lon), bounds_error=False, fill_value=0.0)
def test_nonscalar_values(self): # Verify that non-scalar valued values also works points, values = self._sample_4d_data() np.random.seed(1234) values = np.random.rand(3, 3, 3, 3, 6) sample = np.random.rand(7, 11, 4) for method in ['nearest', 'linear']: v = interpn(points, values, sample, method=method, bounds_error=False) assert_equal(v.shape, (7, 11, 6), err_msg=method) vs = [ interpn(points, values[..., j], sample, method=method, bounds_error=False) for j in range(6) ] v2 = np.array(vs).transpose(1, 2, 0) assert_allclose(v, v2, err_msg=method) # Vector-valued splines supported with fitpack assert_raises(ValueError, interpn, points, values, sample, method='splinef2d')
def warpImg(self, hi_vol, lo_vol): new_coords = np.stack( [self._defFieldGen() for idx in range(self._img_dims[0])], axis=0) new_hi_vol = np.zeros(self._img_dims) new_lo_vol = np.zeros(self._img_dims) for idx in range(self._img_dims[0]): new_hi_vol[idx, :, :, :, 0] = sci.interpn( (np.arange(self._img_dims[1]), np.arange( self._img_dims[2]), np.arange(self._img_dims[3])), hi_vol[idx, :, :, :, 0], new_coords[idx, ...], method='linear', fill_value=0, bounds_error=False) new_lo_vol[idx, :, :, :, 0] = sci.interpn( (np.arange(self._img_dims[1]), np.arange( self._img_dims[2]), np.arange(self._img_dims[3])), lo_vol[idx, :, :, :, 0], new_coords[idx, ...], method='linear', fill_value=0, bounds_error=False) self._aff_mat = self._ident_mat return new_hi_vol, new_lo_vol
def RAngCalc(data,sweep_slope,fs): '''create Range angle map for a given data set''' Angle1 = np.linspace(-1,1,len(data.T),endpoint=True) Angle1 = np.degrees(np.arcsin(Angle1)) #arcsin as the array factor is proportional to the sin Freq = np.linspace(0,fs,len(data),endpoint=True) Range = (Freq*3e8) / (2*sweep_slope) R = np.fft.fft(data,None,0) A = np.fft.fft(data,None,1) A = np.fft.fftshift(A,1) ReflecMap = np.fft.fft(R,None,1) ReflecMap = np.fft.fftshift(ReflecMap,1) #create range and angle map for input data interp_ratio = 1#20 #ratio of initial array elements vs interpolated elements Angle = np.linspace(-1,1,len(data.T)*interp_ratio,endpoint=True) #create new angle vector to plot against Angle = np.degrees(np.arcsin(Angle)) #to go from psi to angle representations interp_mesh = np.array(np.meshgrid(Range, Angle, indexing='ij')) interp_points = np.rollaxis(interp_mesh, 0, 3).reshape((-1, 2)) #create list of cooridnates to interpolate at A = si.interpn((Range,Angle1),A,interp_points) A = np.reshape(A,(len(Range), len(Angle))) ReflecMap = si.interpn((Range,Angle1),ReflecMap,interp_points) ReflecMap = np.reshape(ReflecMap,(len(Range), len(Angle))) return [Range, Angle, R, A, ReflecMap]
def probe_data(self,rad,lat,lon,**kwargs): ''' returns the value of the field at the point specified. params: lat lon depth ''' type = kwargs.get('type','point') if type == 'cell': p1 = self.rad[0:len(self.rad)-1] p2 = self.lat[0:len(self.lat)-1] p3 = self.lon[0:len(self.lon)-1] return interpn(points = (p1,p2,p3), values = self.data, xi = (rad,lat,lon), bounds_error=False, fill_value = 0.0) elif type == 'point': return interpn(points=(self.rad,self.lat,self.lon), values=self.data_pts, xi = (rad,lat,lon), bounds_error=False, fill_value = 0.0)
def test_descending_points(self): def value_func_4d(x, y, z, a): return 2 * x**3 + 3 * y**2 - z - a x1 = np.array([0, 1, 2, 3]) x2 = np.array([0, 10, 20, 30]) x3 = np.array([0, 10, 20, 30]) x4 = np.array([0, .1, .2, .30]) points = (x1, x2, x3, x4) values = value_func_4d( *np.meshgrid(*points, indexing='ij', sparse=True)) pts = (0.1, 0.3, np.transpose(np.linspace(0, 30, 4)), np.linspace(0, 0.3, 4)) correct_result = interpn(points, values, pts) x1_descend = x1[::-1] x2_descend = x2[::-1] x3_descend = x3[::-1] x4_descend = x4[::-1] points_shuffled = (x1_descend, x2_descend, x3_descend, x4_descend) values_shuffled = value_func_4d( *np.meshgrid(*points_shuffled, indexing='ij', sparse=True)) test_result = interpn(points_shuffled, values_shuffled, pts) assert_array_equal(correct_result, test_result)
def interp_depth_model(model, lat, lon, new_dep): """ Interpolate Vp and Vs from 3D velocity with a specified depth range. Parameters ---------- mod3d : :meth:`np.lib.npyio.NpzFile` 3D velocity loaded from a ``.npz`` file lat : float Latitude of position in 3D velocity model lon : float Longitude of position in 3D velocity model new_dep : :meth:`np.ndarray` 1D array of depths in km Returns ------- Vp : :meth:`np.ndarray` Vp in ``new_dep`` Vs : :meth:`np.ndarray` Vs in ``new_dep`` """ # model = np.load(modpath) points = [[depth, lat, lon] for depth in new_dep] vp = interpn((model['dep'], model['lat'], model['lon']), model['vp'], points, bounds_error=False, fill_value=None) vs = interpn((model['dep'], model['lat'], model['lon']), model['vs'], points, bounds_error=False, fill_value=None) return vp, vs
def mapped(u, y, x, yyT, xxT, i): # Return the warped signal ny = len(y) nx = len(x) yc = np.linspace(0, ny - 1, (2**i + 1), dtype=int) xc = np.linspace(0, nx - 1, (2**i + 1), dtype=int) xx, yy = np.meshgrid(x, y, indexing='ij') # Transform coordinate Tt = interpolate.interpn((x[xc], y[yc]), yyT, np.array([xx.reshape(-1), yy.reshape(-1)]).T, method='linear') Tx = interpolate.interpn((x[xc], y[yc]), xxT, np.array([xx.reshape(-1), yy.reshape(-1)]).T, method='linear') # Interpolated function uT = interpolate.interpn((x, y), u, np.array([Tx, Tt]).T, method='linear', bounds_error=False, fill_value=None) # ,fill_value=1000) return uT.reshape(nx, ny)
def test_length_one_axis(self): # gh-5890, gh-9524 : length-1 axis is legal for method='linear'. # Along the axis it's linear interpolation; away from the length-1 # axis, it's an extrapolation, so fill_value should be used. values = np.array([[0.1, 1, 10]]) xi = np.array([[1, 2.2], [1, 3.2], [1, 3.8]]) res = interpn(([1], [2, 3, 4]), values, xi) wanted = [ 0.9 * 0.2 + 0.1, # on [2, 3) it's 0.9*(x-2) + 0.1 9 * 0.2 + 1, # on [3, 4] it's 9*(x-3) + 1 9 * 0.8 + 1 ] assert_allclose(res, wanted, atol=1e-15) # check extrapolation xi = np.array([[1.1, 2.2], [1.5, 3.2], [-2.3, 3.8]]) res = interpn(([1], [2, 3, 4]), values, xi, bounds_error=False, fill_value=None) assert_allclose(res, wanted, atol=1e-15)
def test_xi_1d(self): # verify that 1-D xi works as expected points, values = self._sample_4d_data() sample = np.asarray([0.1, 0.1, 10., 9.]) v1 = interpn(points, values, sample, bounds_error=False) v2 = interpn(points, values, sample[None, :], bounds_error=False) assert_allclose(v1, v2)
def shiftParticle(original, displacement, gridNumber, boxsize, boxmin): boxRange = np.arange(gridNumber) boxGrid = np.array([boxRange for i in range(3)]) new = original.copy() new[0] = (original[0] - boxmin) * (gridNumber - 1) / boxsize new[1] = (original[1] - boxmin) * (gridNumber - 1) / boxsize new[2] = (original[2] - boxmin) * (gridNumber - 1) / boxsize xinterp = interpolate.interpn(boxGrid, displacement[0], new.T, bounds_error=False, fill_value=0).real yinterp = interpolate.interpn(boxGrid, displacement[1], new.T, bounds_error=False, fill_value=0).real zinterp = interpolate.interpn(boxGrid, displacement[2], new.T, bounds_error=False, fill_value=0).real new[0] = (new[0]) * (boxsize) / (gridNumber - 1) + boxmin + xinterp new[1] = (new[1]) * (boxsize) / (gridNumber - 1) + boxmin + yinterp new[2] = (new[2]) * (boxsize) / (gridNumber - 1) + boxmin + zinterp new = new.transpose() return (new)
def advect_once(self, dt): fdt = self._ft[1] - self._ft[0] if type(fdt) is not numpy.float64: fdt = timedelta(fdt).total_seconds() x = [] y = [] t = [] for p in self._data: x.append(p.pt[0]) y.append(p.pt[1]) t.append(p.pt[2]) pts = (numpy.array(t), numpy.array(y), numpy.array(x)) us = interpn(self._gdims, self._fu, pts, method='linear', fill_value=.0) vs = interpn(self._gdims, self._fv, pts, method='linear', fill_value=.0) for i, p in enumerate(self._data): # p.advect(self._fu, self._fv, self._gdims, dt, fdt) p.advect_uv(us[i], vs[i], self._gdims, dt, fdt) self._simtime += dt
def test_xi_broadcast(self): # verify that the interpolators broadcast xi x, y, values = self._sample_2d_data() points = (x, y) xi = np.linspace(0, 1, 2) yi = np.linspace(0, 3, 3) for method in ['nearest', 'linear', 'splinef2d']: sample = (xi[:, None], yi[None, :]) v1 = interpn(points, values, sample, method=method, bounds_error=False) assert_equal(v1.shape, (2, 3)) xx, yy = np.meshgrid(xi, yi) sample = np.c_[xx.T.ravel(), yy.T.ravel()] v2 = interpn(points, values, sample, method=method, bounds_error=False) assert_allclose(v1, v2.reshape(v1.shape))
def build_basement(self,tXY,id): """ Using Pandas library to read the basement map file and define consolidated and soft sediment region. """ self.tXY = tXY # Read basement file if id == 1: self.tinBase1 = numpy.ones(len(tXY)) Bmap = pandas.read_csv(str(self.baseMap), sep=r'\s+', engine='c', header=None, na_filter=False, dtype=numpy.float, low_memory=False) rectBase = numpy.reshape(Bmap.values,(len(self.regX), len(self.regY)),order='F') self.tinBase1[self.boundsPt:] = interpolate.interpn( (self.regX, self.regY), rectBase, tXY[self.boundsPt:,:], method='linear') elif id == 2: self.tinBase2 = numpy.ones(len(tXY)) Bmap = pandas.read_csv(str(self.baseMap2), sep=r'\s+', engine='c', header=None, na_filter=False, dtype=numpy.float, low_memory=False) rectBase = numpy.reshape(Bmap.values,(len(self.regX), len(self.regY)),order='F') self.tinBase2[self.boundsPt:] = interpolate.interpn( (self.regX, self.regY), rectBase, tXY[self.boundsPt:,:], method='linear') return
def main(): """ Main routine """ parser = argparse.ArgumentParser() parser.add_argument("-i", "--input", help="Input file", default="data.cub") parser.add_argument("-p", "--point", help="One point of the plane", type=float, nargs=3, default=(0., 0., 0.)) parser.add_argument("-n", "--normal", help="The normal of the plane", type=float, nargs=3, default=(1., 0., 0.)) args = parser.parse_args() point_in_plane = np.array([args.point[0], args.point[1], args.point[2]]) normal_to_plane = np.array([args.normal[0], args.normal[1], args.normal[2]]) filename = args.input cubedata = Cubefile(filename) cubedata.print() print(cubedata.origin) print(cubedata.getgrid()[0]) print(cubedata.data[0, 0, 0]) Vi = interpn((cubedata.getXvalues(), cubedata.getYvalues(), cubedata.getZvalues()), cubedata.data, np.array([[-17.5615, -12.8185, -6.83306 + i*0.759228] for i in range(19)])) for i in range(19): print("{:1.8f} {:1.12f}".format(-6.83306+i*0.759228, Vi[i])) Vi = interpn((cubedata.getXvalues(), cubedata.getYvalues(), cubedata.getZvalues()), cubedata.data, np.array([[-17.5615, -12.8185, -6.83306 + i*0.075922] for i in range(179)])) for i in range(179): print("{:1.8f} {:1.12f}".format(-6.83306 + i * 0.075922, Vi[i]))
def fscaling3D(X_train, X_test, scpatchSize, iscalefactor): afterSize = np.ceil(np.multiply(scpatchSize, iscalefactor)).astype(int) # Prepare for the using of scipy.interpolation: create the coordinates of grid if iscalefactor == 1: return X_train, X_test, scpatchSize else: xaxis = np.linspace(0, afterSize[0], scpatchSize[0]) yaxis = np.linspace(0, afterSize[1], scpatchSize[1]) zaxis = np.linspace(0, afterSize[2], scpatchSize[2]) dAllx_train = None dAllx_test = None for ifold in range(len(X_train)): lenTrain = X_train[ifold].shape[0] lenTest = X_test[ifold].shape[0] start = time.clock() # no batch inter_train0 = np.mgrid[0:lenTrain, 0:afterSize[0], 0:afterSize[1], 0:afterSize[2]] inter_train1 = np.rollaxis(inter_train0, 0, 5) inter_train = np.reshape(inter_train1, [inter_train0.size // 4, 4]) # 4 for the dimension of coordinates zaxis_train = np.arange(lenTrain) upedTrain = interpolate.interpn((zaxis_train, xaxis, yaxis, zaxis), X_train[ifold], inter_train, method='linear', bounds_error=False, fill_value=0) dFoldx_train = np.reshape(upedTrain, [1, lenTrain, afterSize[0], afterSize[1], afterSize[2]]) inter_test0 = np.mgrid[0:lenTest, 0:afterSize[0], 0:afterSize[1], 0:afterSize[2]] inter_test1 = np.rollaxis(inter_test0, 0, 5) inter_test = np.reshape(inter_test1, [inter_test0.size // 4, 4]) # 4 for the dimension of coordinates zaxis_test = np.arange(lenTest) upedTest = interpolate.interpn((zaxis_test, xaxis, yaxis, zaxis), X_test[ifold], inter_test, method='linear', bounds_error=False, fill_value=0) dFoldx_test = np.reshape(upedTest, [1, lenTest, afterSize[0], afterSize[1], afterSize[2]]) stop = time.clock() print(stop-start) if dAllx_train is None: dAllx_train = dFoldx_train else: dAllx_train = np.concatenate((dAllx_train, dFoldx_train), axis=0) if dAllx_test is None: dAllx_test = dFoldx_test else: dAllx_test = np.concatenate((dAllx_test, dFoldx_test), axis=0) return dAllx_train, dAllx_test, afterSize
def create_scales(input, idx): if 'stacks_v_s4' in input: input['stacks_v_s4'][idx] = np.clip(input['stacks_v_HR'][idx], 16.0 / 255.0, 240 / 255) input['stacks_h_s4'][idx] = np.clip(input['stacks_h_HR'][idx], 16.0 / 255.0, 240 / 255) input['stacks_v_s2'][idx] = np.clip( np.stack([ cv2.resize(input['stacks_v_HR'][idx][i, :, :, :], (96, 96), interpolation=cv2.INTER_CUBIC) for i in range(0, 9) ]), 16.0 / 255.0, 240 / 255) input['stacks_h_s2'][idx] = np.clip( np.stack([ cv2.resize(input['stacks_h_HR'][idx][i, :, :, :], (96, 96), interpolation=cv2.INTER_CUBIC) for i in range(0, 9) ]), 16.0 / 255.0, 240 / 255) input['stacks_v'][idx] = np.clip( np.stack([ cv2.resize(input['stacks_v_HR'][idx][i, :, :, :], (48, 48), interpolation=cv2.INTER_CUBIC) for i in range(0, 9) ]), 16.0 / 255.0, 240 / 255) input['stacks_h'][idx] = np.clip( np.stack([ cv2.resize(input['stacks_h_HR'][idx][i, :, :, :], (48, 48), interpolation=cv2.INTER_CUBIC) for i in range(0, 9) ]), 16.0 / 255.0, 240 / 255) else: input['stacks_v_s2'][idx] = np.clip(input['stacks_v_HR'][idx], 16.0 / 255.0, 240 / 255) input['stacks_h_s2'][idx] = np.clip(input['stacks_h_HR'][idx], 16.0 / 255.0, 240 / 255) input['stacks_v'][idx][..., 0:3] = np.clip( np.stack([ cv2.resize(input['stacks_v_HR'][idx][i, :, :, :], (48, 48), interpolation=cv2.INTER_CUBIC) for i in range(0, 9) ]), 16.0 / 255.0, 240 / 255) input['stacks_h'][idx][..., 0:3] = np.clip( np.stack([ cv2.resize(input['stacks_h_HR'][idx][i, :, :, :], (48, 48), interpolation=cv2.INTER_CUBIC) for i in range(0, 9) ]), 16.0 / 255.0, 240 / 255) # biclinear stuff [tq, vq, uq] = np.meshgrid(range(9), range(48), range(48)) tq = tq.transpose(1, 0, 2) vq = vq.transpose(1, 0, 2) uq = uq.transpose(1, 0, 2) points = [[0, 4, 8], np.arange(48), np.arange(48)] xi = (tq.ravel(), vq.ravel(), uq.ravel()) for ch in range(0, 3): input['stacks_bicubic_v'][idx][:, :, :, ch] = np.clip( interpn(points, input['stacks_v'][idx][0:9:4, :, :, ch], xi).reshape((9, 48, 48)), 16.0 / 255.0, 240 / 255) input['stacks_bicubic_h'][idx][:, :, :, ch] = np.clip( interpn(points, input['stacks_h'][idx][0:9:4, :, :, ch], xi).reshape((9, 48, 48)), 16.0 / 255.0, 240 / 255) return (input)
def reddening(vlong, ulong, vlat, ulat, frame, step_pc=5): """Calculate Reddening versus distance from Sun. Args: vlong (str or double): Longitude value. ulong (str): Longitude unit used in :class:`SkyCoord`. vlat (str or double): Latitude value. ulat (str): Latitude unit used in :class:`SkyCoord`. frame (str): Galactic, icrs ... values supported by :class:`SkyCoord`. Kwargs: step_pc (int): Incremental distance in parsec Returns: array: Parsec values. array: E(B-V) value obtain with integral of linear extrapolation. """ # Calculate the position for 1pc sc = SkyCoord(vlong, vlat, distance=1 * u.pc, unit=(ulong, ulat), frame=frame) coords_xyz = sc.transform_to('galactic').represent_as( 'cartesian').get_xyz().value # Find the number of parsec I can calculate before go out the cube # (exclude divide by 0) not0 = np.where(coords_xyz != 0) max_pc = np.amin( np.abs(np.take(max_axes, not0) / np.take(coords_xyz, not0))) # Calculate all coordinates to interpolate (use step_pc) distances = np.arange(0, max_pc, step_pc) sc = SkyCoord(vlong, vlat, distance=distances, unit=(ulong, ulat, 'pc'), frame=frame) sc = sc.transform_to('galactic').represent_as('cartesian') coords_xyz = np.array([coord.get_xyz().value for coord in sc]) # linear interpolation with coordinates interpolation = spi.interpn(axes, cube, coords_xyz, method='linear') xvalues = np.arange(0, len(interpolation) * step_pc, step_pc) yvalues = np.cumsum(interpolation) * step_pc # errors xerrors = spi.interpn(axes, cubeXErr, coords_xyz, method='linear') yerrorsMin = spi.interpn(axes, cubeYErrMin, coords_xyz, method='linear') yerrorsMax = spi.interpn(axes, cubeYErrMax, coords_xyz, method='linear') return (xvalues, np.around(yvalues, decimals=3), np.around(xerrors, decimals=0), np.around(yerrorsMin, decimals=3), np.around(yerrorsMax, decimals=3))
def test__resample(): # Test proper use. shape = (3,4) resolution = 1.5 origin = 'zero' attempted_scales = 1 image = np.arange(np.prod(shape)).reshape(shape) real_axes = _compute_axes(image.shape, resolution, origin=origin) new_shape = np.floor(np.multiply(image.shape, attempted_scales)) real_scales = np.divide(new_shape, image.shape) new_shape = np.floor(np.multiply(np.subtract(image.shape, 1), real_scales)) + 1 new_real_coords = _compute_coords(new_shape, resolution / real_scales, origin=origin) correct_output = interpn(points=real_axes, values=image, xi=new_real_coords) assert np.array_equal(_resample(image, real_axes, new_real_coords), correct_output) shape = (3) resolution = 1 origin = 'zero' attempted_scales = 1 image = np.arange(np.prod(shape)).reshape(shape) real_axes = _compute_axes(image.shape, resolution, origin=origin) new_shape = np.floor(np.multiply(image.shape, attempted_scales)) real_scales = np.divide(new_shape, image.shape) new_shape = np.floor(np.multiply(np.subtract(image.shape, 1), real_scales)) + 1 new_real_coords = _compute_coords(new_shape, resolution / real_scales, origin=origin) correct_output = interpn(points=real_axes, values=image, xi=new_real_coords) assert np.array_equal(_resample(image, real_axes, new_real_coords), correct_output) shape = (3,4,5) resolution = (0.5,1,1.5) origin = 'center' attempted_scales = (1/2,1/3,1/4) image = np.arange(np.prod(shape)).reshape(shape) real_axes = _compute_axes(image.shape, resolution, origin=origin) new_shape = np.floor(np.multiply(image.shape, attempted_scales)) real_scales = np.divide(new_shape, image.shape) new_shape = np.floor(np.multiply(np.subtract(image.shape, 1), real_scales)) + 1 new_real_coords = _compute_coords(new_shape, resolution / real_scales, origin=origin) correct_output = interpn(points=real_axes, values=image, xi=new_real_coords) assert np.array_equal(_resample(image, real_axes, new_real_coords), correct_output) shape = (6,7,8,9) resolution = (0.5,1,1.5,2.5) origin = 'center' attempted_scales = (2,3,3.5,np.pi) image = np.arange(np.prod(shape)).reshape(shape) real_axes = _compute_axes(image.shape, resolution, origin=origin) new_shape = np.floor(np.multiply(image.shape, attempted_scales)) real_scales = np.divide(new_shape, image.shape) new_shape = np.floor(np.multiply(np.subtract(image.shape, 1), real_scales)) + 1 new_real_coords = _compute_coords(new_shape, resolution / real_scales, origin=origin) correct_output = interpn(points=real_axes, values=image, xi=new_real_coords) assert np.array_equal(_resample(image, real_axes, new_real_coords), correct_output)
def _pcax(psd: np.ndarray) -> (np.ndarray, np.ndarray): """ Calculate integrals through the principal axes of psd. :param psd: psd. :return: (intg1, intg2) : two integrals along the two axes. """ n = psd.shape[0] [g2, g1] = np.meshgrid([i for i in range(1, n + 1)], [i for i in range(1, n + 1)]) def trapz2d(tg2, tg1, p): return np.trapz(_trapz2(tg2, p, 1), tg1[:, 0], axis=0) p_n = psd / trapz2d(g2, g1, psd) m2 = trapz2d(g2, g1, p_n * g2) m1 = trapz2d(g2, g1, p_n * g1) c = np.zeros(4) q1 = [2, 1, 1, 0] q2 = [0, 1, 1, 2] for jj in [0, 1, 3]: c[jj] = np.squeeze( trapz2d(g2, g1, p_n * (g2 - m2)**q1[jj] * (g1 - m1)**q2[jj])) c[2] = c[1] c = c.reshape((2, 2)) u, s, v = svd(c) n3 = 3 * n g2_n3, g1_n3 = np.meshgrid( np.array([i for i in range(1, n3 + 1)]) - (n3 + 1) / 2, np.array([i for i in range(1, n3 + 1)]) - (n3 + 1) / 2) # Rotate PSDs and calculate integrals along the rotated PSDs theta = np.angle(u[0, 0] + 1j * u[0, 1]) g2_rot = g2_n3[n:2 * n, n:2 * n] * np.cos(theta) - g1_n3[n:2 * n, n:2 * n] * np.sin(theta) g1_rot = g1_n3[n:2 * n, n:2 * n] * np.cos(theta) + g2_n3[n:2 * n, n:2 * n] * np.sin(theta) psd_rep = np.tile(psd, (3, 3)) psd_rot = interpn((g2_n3[0, :], g2_n3[0, :]), psd_rep, (g1_rot, g2_rot)) int_rot = _trapz2(g1, psd_rot, 0) theta2 = np.angle(u[1, 0] + 1j * u[1, 1]) g2_rot = g2_n3[n:2 * n, n:2 * n] * np.cos(theta2) - g1_n3[ n:2 * n, n:2 * n] * np.sin(theta2) g1_rot = g1_n3[n:2 * n, n:2 * n] * np.cos(theta2) + g2_n3[ n:2 * n, n:2 * n] * np.sin(theta2) psd_rot2 = interpn((g2_n3[0, :], g2_n3[0, :]), psd_rep, (g1_rot, g2_rot)) int_rot2 = _trapz2(g1, psd_rot2, 0) return int_rot, int_rot2
def test_invalid_xi_dimensions(self): # https://github.com/scipy/scipy/issues/16519 points = [(0, 1)] values = [0, 1] xi = np.ones((1, 1, 3)) msg = ("The requested sample points xi have dimension 3, but this " "RegularGridInterpolator has dimension 1") with assert_raises(ValueError, match=msg): interpn(points, values, xi)
def generate_surface_image(image_pk): from neurovault.apps.statmaps.models import Image from scipy.io import loadmat import numpy.matlib as matlib from scipy.interpolate import interpn img = Image.objects.get(pk=image_pk) if img.target_template_image in ['GenericMNI', 'MNI152NLin2009cAsym'] and \ img.data_origin == 'volume': img_vol = nib.load(img.file.path) data_vol = img_vol.get_data() if data_vol.ndim > 3: data_dim = data_vol.shape[3] #number of time points else: data_dim = 1 this_path = os.path.abspath(os.path.dirname(__file__)) for hemi in ['lh', 'rh']: if hemi == 'lh': ras_coor = loadmat(os.path.abspath(os.path.join(this_path, "static", "anatomical", "lh.avgMapping_allSub_RF_ANTs_MNI2fs.mat")))['ras'] else: ras_coor = loadmat(os.path.abspath(os.path.join(this_path, "static", "anatomical", "rh.avgMapping_allSub_RF_ANTs_MNI2fs.mat")))['ras'] vox2ras = img_vol.get_sform() ras_centered = ras_coor - matlib.repmat(vox2ras[0:3, 3], ras_coor.shape[1], 1).T vox_coor = numpy.dot(numpy.linalg.inv(vox2ras[0:3, 0:3]), ras_centered) # convert to voxel coordinates img_surf = nib.gifti.GiftiImage() for i in range(data_dim): if data_vol.ndim > 3: data_curr = data_vol[:, :, :, i] data_surf = interpn([range(data_vol.shape[0]), range(data_vol.shape[1]), range(data_vol.shape[2])], data_curr, vox_coor.T, 'linear') data_surf_gifti = nib.gifti.GiftiDataArray(data_surf, 'NIFTI_INTENT_TIME_SERIES', 'NIFTI_TYPE_FLOAT32', 'ASCII') else: data_curr = data_vol data_surf = interpn([range(data_vol.shape[0]), range(data_vol.shape[1]), range(data_vol.shape[2])], data_curr, vox_coor.T, 'linear') data_surf_gifti = nib.gifti.GiftiDataArray(data_surf, 'NIFTI_INTENT_NONE', 'NIFTI_TYPE_FLOAT32', 'ASCII') img_surf.add_gifti_data_array(data_surf_gifti) f = BytesIO() fmap = {'image': nib.FileHolder(fileobj=f), 'header': nib.FileHolder(fileobj=f)} img_surf.to_file_map(fmap) f.seek(0) content_file = ContentFile(f.read()) if hemi == 'lh': img.surface_left_file.save("surface_%s_%s.gii" % (hemi, img.pk), content_file) else: img.surface_right_file.save("surface_%s_%s.gii" % (hemi, img.pk), content_file) img.save() print("Surface image generation done.")
def add_latlon(self, latmat=None, lonmat=None): if latmat is None: latmat = self.latmat if lonmat is None: lonmat = self.lonmat ijtup = (np.arange(lonmat.shape[0]),np.arange(lonmat.shape[1])) xyarr = self._obj[["ypos","xpos"]].values xyarr[xyarr<0] = 0 self._obj["lon"] = interpn(ijtup, lonmat, xyarr).astype(np.float32) self._obj["lat"] = interpn(ijtup, latmat, xyarr).astype(np.float32)
def test_duck_typed_values(self): x = np.linspace(0, 2, 5) y = np.linspace(0, 1, 7) values = MyValue((5, 7)) for method in ('nearest', 'linear'): v1 = interpn((x, y), values, [0.4, 0.7], method=method) v2 = interpn((x, y), values._v, [0.4, 0.7], method=method) assert_allclose(v1, v2)
def convert_hintp(sio, bmap, conf, X3d, X2d, dlon, dlat, missing): """ """ nv3d = X3d.shape[0] nv2d = X2d.shape[0] nz = X3d.shape[1] ny = X3d.shape[2] nx = X3d.shape[3] dx = sio.dimdef['coor_g']['x'][sio.bufsize+1] - sio.dimdef['coor_g']['x'][sio.bufsize] dy = sio.dimdef['coor_g']['y'][sio.bufsize+1] - sio.dimdef['coor_g']['y'][sio.bufsize] lon = sio.readvar('lon') lat = sio.readvar('lat') lon_s = np.floor(np.min(lon) / dlon) * dlon lon_e = np.ceil(np.max(lon) / dlon) * dlon lat_s = np.floor(np.min(lat) / dlat) * dlat lat_e = np.ceil(np.max(lat) / dlat) * dlat lono1d = np.arange(lon_s, lon_e+1.e-6, dlon) lato1d = np.arange(lat_s, lat_e+1.e-6, dlat) nxo = len(lono1d) nyo = len(lato1d) lono, lato = np.meshgrid(lono1d, lato1d) X3dout = np.empty((nv3d, nz, nyo, nxo), dtype=X3d.dtype) X2dout = np.empty((nv2d, nyo, nxo), dtype=X2d.dtype) ri, rj = bmap(lono, lato) ri /= dx rj /= dy rij_interp = np.empty((nxo*nyo, 2), dtype=X3d.dtype) rij_interp[:,0] = rj.ravel() rij_interp[:,1] = ri.ravel() xic = np.arange(nx, dtype=X3d.dtype) + sio.bufsize xjc = np.arange(ny, dtype=X3d.dtype) + sio.bufsize missing = np.array(missing, dtype=X3d.dtype).ravel()[0] for iv in range(nv3d): for iz in range(nz): tmp2d = np.copy(X3d[iv,iz,:,:]) tmp2d[tmp2d == missing] = np.nan X3dout[iv,iz,:,:] = interpn((xjc, xic), tmp2d, rij_interp, method='linear', bounds_error=False, fill_value=missing).reshape(nyo, nxo) for iv in range(nv2d): tmp2d = np.copy(X2d[iv,:,:]) tmp2d[tmp2d == missing] = np.nan X2dout[iv,:,:] = interpn((xjc, xic), tmp2d, rij_interp, method='linear', bounds_error=False, fill_value=missing).reshape(nyo, nxo) return X3dout, X2dout, lon_s, lon_e, nxo, lat_s, lat_e, nyo
def interp(self, mask, spacing): ''' :param mask: new mask in space of 7.5 mm around keypoint :param spacing :spacing after interpolation :return: mask after interpolation ''' self.spacing = spacing # new grid in mm in range of 15 mm from 0-8 mm, with points on a cross in a ceneter of mask new_grid_range_x = np.arange(0, self.mask_shape / 2 + 1, 1) new_pixel_distance_x = np.sort(np.concatenate((-new_grid_range_x[1:], new_grid_range_x))) # new_pixel_distance_z = np.sort(np.concatenate((-new_grid_range_x[1:], new_grid_range_x))) # grid from mask in mm after rotate, spacing under consideration grid is irregular print(spacing) grid_range_x = np.arange(0, ((mask.shape[0] / 2.) * self.spacing[0]), self.spacing[0]) grid_range_y = np.arange(0, ((mask.shape[1] / 2.) * self.spacing[1]), self.spacing[1]) grid_range_z = np.arange(0, ((mask.shape[2] / 2.) * self.spacing[2]), self.spacing[2]) pixel_distance_x = np.sort(np.concatenate((-grid_range_x[1:], grid_range_x))) pixel_distance_y = np.sort(np.concatenate((-grid_range_y[1:], grid_range_y))) pixel_distance_z = np.sort(np.concatenate((-grid_range_z[1:], grid_range_z))) print(pixel_distance_x.max(),pixel_distance_y.max(),pixel_distance_z.max()) print(new_grid_range_x.max()) x, y, z = np.meshgrid(new_pixel_distance_x, new_pixel_distance_x, new_pixel_distance_x, indexing='ij') interpolate_grid = np.array([x[:, :, :], y[:, :, :], z[:, :, :]]).T new_mask = interpn((pixel_distance_x, pixel_distance_y, pixel_distance_z ), mask, interpolate_grid, bounds_error=True, fill_value=np.float32(0.0)) return new_mask.T
def atk3(dataobj, Eb, kx, ky, makegrid=True): if makegrid: if not (type(kx) == np.ndarray): kx = np.array([kx]) if not (type(ky) == np.ndarray): ky = np.array([ky]) if not (type(Eb) == np.ndarray): Eb = np.array([Eb]) gridEb, gridkx, gridky = np.meshgrid(Eb, kx, ky) else: # if providing own grid gridEb = Eb gridkx = kx gridky = ky gridth, gridphi = anglesfromk( gridkx, gridky, dataobj.EkatEF + gridEb, theta_m=dataobj.theta_m, phi_m=dataobj.phi_m, alpha0=dataobj.alpha0, theta0=dataobj.theta0, phi0=dataobj.phi0, ) intgrid = np.array([gridEb, gridth, gridphi]).transpose((2, 1, 3, 0)) return interpn( (dataobj.xaxis, dataobj.yaxis, dataobj.zaxis), dataobj.data, intgrid, bounds_error=False, fill_value=0.0 )
def __call__(self, mask_size, sigma): """ :param mask_size: size of mask in [mm] should depend on real size od :param sigma: sigma is a LoG parameter :return: kernel with new size depending on mask_size and spacing and new values """ pixel_size_of_mask = ceil(mask_size / self.spacing[0]) pixel_size_of_mask = pixel_size_of_mask + ((pixel_size_of_mask - 1) % 2) # object for getting log with appropriate sigma self.LoG2D = LoG2D(sigma) LoG_kernel = self.LoG2D.get_LoG() self.x, self.y = self.LoG2D.get_grid_x_y() # grid for interpolate value index_value = np.linspace(0, self.x.size - 1, pixel_size_of_mask).astype(dtype=np.int) index_value[-1] = self.x.size - 1 max_value_index = np.unravel_index(LoG_kernel.argmax(), LoG_kernel.shape)[0] if not (max_value_index in index_value): index_value[-2] = max_value_index index_value.sort() #1D array one = np.ones((pixel_size_of_mask,)).astype(dtype=np.int) list_for_grid_temp = [] for i in index_value: list_for_grid_temp.append(np.array([self.x[index_value], self.x[i * one]]).T) interpolate_grid = np.array(list_for_grid_temp) print(interpolate_grid) #interpolation kernel = interpn((self.x, self.y), LoG_kernel, interpolate_grid) return kernel
def getElevation(rX, rY, rZ, coords, interp='linear'): """ This function interpolates elevation from a regular grid to a cloud of points using SciPy interpolation. Parameters ---------- variable : rX, rY, rZ Numpy arrays containing the X, Y & Z coordinates from the regular grid. variable : coords Numpy float-type array containing X, Y coordinates for the TIN nodes. variable : interp Define the interpolation technique as in SciPy interpn function. The default is 'linear' Return ---------- variable: elev Numpy array containing the updated elevations for the local domain. """ # Set new elevation to 0 elev = numpy.zeros(len(coords[:,0])) # Get the TIN points elevation values using the regular grid dataset elev = interpn( (rX, rY), rZ, (coords[:,:2]), method=interp) return elev
def evaluate(self, *inputs): """ Return the interpolated values at the input coordinates. Parameters ---------- inputs : list of scalars or ndarrays Input coordinates. The number of inputs must be equal to the dimensions of the lookup table. """ if isinstance(inputs, u.Quantity): inputs = inputs.value shape = inputs[0].shape inputs = [inp.flatten() for inp in inputs[: self.n_inputs]] inputs = np.array(inputs).T if not has_scipy: # pragma: no cover raise ImportError("This model requires scipy >= v0.14") result = interpn(self.points, self.lookup_table, inputs, method=self.method, bounds_error=self.bounds_error, fill_value=self.fill_value) # return_units not respected when points has no units if (isinstance(self.lookup_table, u.Quantity) and not isinstance(self.points[0], u.Quantity)): result = result * self.lookup_table.unit if self.n_outputs == 1: result = result.reshape(shape) else: result = [r.reshape(shape) for r in result] return result
def _plot_cwt(ts, coefs, freqs, tsize=1024, fsize=512): """Plot time resolved power spectral density from cwt results Args: ts: the original Timeseries coefs: continuous wavelet transform coefficients as calculated by cwt() freqs: list of frequencies (in Hz) corresponding to coefs. tsize, fsize: size of the plot (time axis and frequency axis, in pixels) """ import matplotlib.style import matplotlib as mpl mpl.style.use('classic') import matplotlib.pyplot as plt from scipy import interpolate channels = ts.shape[1] fig = plt.figure() for i in range(channels): rect = (0.1, 0.85*(channels - i - 1)/channels + 0.1, 0.8, 0.85/channels) ax = fig.add_axes(rect) logpowers = np.log((coefs[:, :, i] * coefs[:, :, i].conj()).real) tmin, tmax = ts.tspan[0], ts.tspan[-1] fmin, fmax = freqs[0], freqs[-1] tgrid, fgrid = np.mgrid[tmin:tmax:tsize*1j, fmin:fmax:fsize*1j] gd = interpolate.interpn((ts.tspan, freqs), logpowers, (tgrid, fgrid)).T ax.imshow(gd, cmap='gnuplot2', aspect='auto', origin='lower', extent=(tmin, tmax, fmin, fmax)) ax.set_ylabel('freq (Hz)') fig.axes[0].set_title(u'log(power spectral density)') fig.axes[channels - 1].set_xlabel('time (s)') fig.show()
def CalibrationHa(z,oldLum,it): newLum = [0. for x in range((it.shape[0]))] oldpara = np.array([[0. for i in range(3)] for i in range(it.shape[0])]) oldLF = np.array([0. for i in range(it.shape[0])]) interpolatingSize =100 for i in range(oldpara.shape[0]): oldpara[i][0] = 1.37e-3 oldpara[i][2] = -1.35 if z[it[i]] <1.3 :oldpara[i][1] = 5.1e41*np.power((1+z[it[i]]),3.1) if z[it[i]] >=1.3:oldpara[i][1] =6.8e42 oldLF[i] = LuminosityFunction(oldpara[i],oldLum[i]) rangea = oldLF.copy() rangea.sort() rangea = rangea[rangea>0] grid = np.array([[0. for i in range(interpolatingSize)] for i in range(2)]) mpgrid = mpmath.arange(mpmath.log10(rangea.min()),mpmath.log10(rangea.max()),(np.log10(rangea.max())-np.log10(rangea.min()))/interpolatingSize) grid[0] = np.ogrid[np.log10(rangea.min()):np.log10(oldLF.max()):interpolatingSize*1j] grid[1] = np.ogrid[0:6:interpolatingSize*1j] newLF = np.array([[0.for i in range(interpolatingSize)] for i in range(interpolatingSize)]) for i in range(interpolatingSize): for j in range(interpolatingSize): newLF[i][j]= optimize.brentq(rootfinding,1e30,1e50,args=(luminosityParameterHa(grid[1][i]),mpgrid[j])) newLum = interpolate.interpn([grid[0],grid[1]],newLF,np.array([np.log10(oldLF),z[it]]).T,bounds_error=False,fill_value=0.0) newLum = np.power(10,newLum) return newLum
def eval(self, dx, dy, x0, y0, x_box=None, y_box=None): """Return the PSF at a certain grid position. :param float dx: x offset relative to PSF center :param float dy: y offset relative to PSF center :param float x0: x position on grid :param float y0: y position on grid :return: interpolated PSF :rtype: array """ grid_points = self.grid_points grid_size = self.grid_size if x_box is None: x_box = self.x_box if y_box is None: y_box = self.y_box # get individual PSFs at the given offset values = np.empty((grid_size, grid_size, len(x_box), len(y_box))) for i, j in np.ndindex(grid_size, grid_size): values[i, j] = self.psf_arr[i, j].eval(x_box+dx, y_box+dy) # get the local PSF at the given grid position if self.grid_size == 1: return values[0, 0] else: return interpn(grid_points, values, (x0, y0), method="linear", bounds_error=False, fill_value=None)[0]
def interpolatePoints(array, points, pointbounds): depth, rows, cols = array.shape y = np.linspace(pointbounds.bottom, pointbounds.top, rows) x = np.linspace(pointbounds.left, pointbounds.right, cols) return np.rot90(np.array( [interpolate.interpn((x, y), np.rot90(arr, k=3), points, bounds_error=False).astype(array.dtype) for arr in array] )[::-1], k=3)
def shiftParticle(original,displacement,gridNumber,boxsize,boxmin): boxRange = np.arange(gridNumber) boxGrid = np.array([boxRange for i in range(3)]) new = original.copy() new[0] = (original[0]-boxmin)*(gridNumber-1)/boxsize new[1] = (original[1]-boxmin)*(gridNumber-1)/boxsize new[2] = (original[2]-boxmin)*(gridNumber-1)/boxsize xinterp = interpolate.interpn(boxGrid,displacement[0],new.T,bounds_error=False,fill_value = 0).real yinterp = interpolate.interpn(boxGrid,displacement[1],new.T,bounds_error=False,fill_value = 0).real zinterp = interpolate.interpn(boxGrid,displacement[2],new.T,bounds_error=False,fill_value = 0).real print 'The rms displacement is' print np.sqrt(np.sum(xinterp*xinterp+yinterp*yinterp+zinterp*zinterp)/(3*xinterp.size())) print 'The first 10 interpolated value of x displacement is' print new[0].min(),new[0].max(),new[1].min(),new[1].max(),new[2].min(),new[2].max(),xinterp.max(),yinterp.max(),zinterp.max(),xinterp.min(),yinterp.min(),zinterp.min() new[0] = (new[0])*(boxsize)/(gridNumber-1)+boxmin+xinterp new[1] = (new[1])*(boxsize)/(gridNumber-1)+boxmin+yinterp new[2] = (new[2])*(boxsize)/(gridNumber-1)+boxmin+zinterp new = new.transpose() return new
def triangulation_compute_gradient(self, values, res=None, second=False): from scipy.interpolate import griddata from scipy.interpolate import interpn if res == None: res = int(1.0 / self.edge_lengths.max()) resX=res resY=res space = 1.0 / (res-1.0) minX, minY = self.lagrSwarm.mesh.data.min(axis=0) maxX, maxY = self.lagrSwarm.mesh.data.max(axis=0) xs = np.linspace(minX, maxX, resX) ys = np.linspace(minY, maxY, resY) gradmesh = np.array(np.meshgrid(xs, ys)).transpose(2,1,0) gradvals = griddata( self.triangulation.points, values, gradmesh, method="cubic" ) # Cubic not available in 3D ... dFdx, dFdy = np.gradient(gradvals.reshape(resX,resY), space, edge_order=1) if second: d2Fdx2, d2Fdxdy = np.gradient(dFdx.reshape(resX,resY), space, edge_order=1) d2Fdydx, d2Fdy2 = np.gradient(dFdy.reshape(resX,resY), space, edge_order=1) # Now map these back to the node points dFdxN = interpn((xs,ys), dFdx, self.triangulation.points, method="linear") dFdyN = interpn((xs,ys), -dFdy, self.triangulation.points, method="linear") if second: dF2dx2N = interpn((xs,ys), d2Fdx2, self.triangulation.points, method="linear") dF2dy2N = interpn((xs,ys), d2Fdy2, self.triangulation.points, method="linear") dF2dyxN = interpn((xs,ys), d2Fdydx+d2Fdxdy, self.triangulation.points, method="linear") if not second: return dFdxN, dFdyN else: return dFdxN, dFdyN, dF2dx2N, dF2dyxN, dF2dy2N
def generate_surface_image(image_pk): from neurovault.apps.statmaps.models import Image from scipy.io import loadmat from scipy.interpolate import interpn img = Image.objects.get(pk=image_pk) if img.target_template_image in ['GenericMNI', 'MNI152NLin2009cAsym'] and \ img.data_origin == 'volume': img_vol = nib.load(img.file.path) data_vol = img_vol.get_data() if data_vol.ndim > 3: data_vol = data_vol[:, :, :, 0] #number of time points this_path = os.path.abspath(os.path.dirname(__file__)) for hemi in ['lh', 'rh']: ras_coor = loadmat(os.path.abspath(os.path.join(this_path, "static", "anatomical", "%s.avgMapping_allSub_RF_ANTs_MNI2fs.mat" % hemi)))['ras'] vox_coor = nib.affines.apply_affine(numpy.linalg.inv(img_vol.affine), ras_coor.T).T img_surf = nib.gifti.GiftiImage() if img.polymorphic_ctype.model == 'atlas' or (hasattr(img, 'map_type') and img.map_type in ['Pa', 'R']): method = 'nearest' else: method = 'linear' data_surf = interpn(points=[range(data_vol.shape[0]), range(data_vol.shape[1]), range(data_vol.shape[2])], values=data_vol, xi=vox_coor.T, method=method, bounds_error=False, fill_value=0) # without turning nan's to zeros Connectome Workbench behaves weird data_surf[numpy.isnan(data_surf)] = 0 # ASCII is the only encoding that produces outputs compatible with Connectome Workbench data_surf_gifti = nib.gifti.GiftiDataArray(data_surf, 'NIFTI_INTENT_NONE', 'NIFTI_TYPE_FLOAT32', 'ASCII') img_surf.add_gifti_data_array(data_surf_gifti) img_surf.meta.data.insert(0, nib.gifti.GiftiNVPairs('AnatomicalStructurePrimary', {'lh': 'CortexLeft', 'rh': 'CortexRight'}[hemi])) f = BytesIO() fmap = {'image': nib.FileHolder(fileobj=f), 'header': nib.FileHolder(fileobj=f)} img_surf.to_file_map(fmap) f.seek(0) content_file = ContentFile(f.read()) if hemi == 'lh': img.surface_left_file.save("%s.%s.func.gii" % (img.pk, {'lh': 'L', 'rh': 'R'}[hemi]), content_file) else: img.surface_right_file.save("%s.%s.func.gii" % (img.pk, {'lh': 'L', 'rh': 'R'}[hemi]), content_file) img.save() print("Surface image generation done.")
def test(model_name, iter_num, gpu_id, vol_size=(160,192,224), nf_enc=[16,32,32,32], nf_dec=[32,32,32,32,32,16,16,3]): """ test nf_enc and nf_dec #nf_dec = [32,32,32,32,32,16,16,3] # This needs to be changed. Ideally, we could just call load_model, and we wont have to # specify the # of channels here, but the load_model is not working with the custom loss... """ gpu = '/gpu:' + str(gpu_id) # Anatomical labels we want to evaluate labels = sio.loadmat('../data/labels.mat')['labels'][0] atlas = np.load('../data/atlas_norm.npz') atlas_vol = atlas['vol'] atlas_seg = atlas['seg'] atlas_vol = np.reshape(atlas_vol, (1,)+atlas_vol.shape+(1,)) config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True set_session(tf.Session(config=config)) # load weights of model with tf.device(gpu): net = networks.unet(vol_size, nf_enc, nf_dec) net.load_weights('../models/' + model_name + '/' + str(iter_num) + '.h5') xx = np.arange(vol_size[1]) yy = np.arange(vol_size[0]) zz = np.arange(vol_size[2]) grid = np.rollaxis(np.array(np.meshgrid(xx, yy, zz)), 0, 4) X_vol, X_seg = datagenerators.load_example_by_name('../data/test_vol.npz', '../data/test_seg.npz') with tf.device(gpu): pred = net.predict([X_vol, atlas_vol]) # Warp segments with flow flow = pred[1][0, :, :, :, :] sample = flow+grid sample = np.stack((sample[:, :, :, 1], sample[:, :, :, 0], sample[:, :, :, 2]), 3) warp_seg = interpn((yy, xx, zz), X_seg[0, :, :, :, 0], sample, method='nearest', bounds_error=False, fill_value=0) vals, _ = dice(warp_seg, atlas_seg, labels=labels, nargout=2) print(np.mean(vals), np.std(vals))
def evaluate(self, *inputs): """ Return the interpolated values at the input coordinates. Parameters ---------- inputs : list of scalars or ndarrays Input coordinates. The number of inputs must be equal to the dimensions of the lookup table. """ inputs = np.array(inputs[: self.n_inputs]).T if not has_scipy: raise ImportError("This model requires scipy >= v0.14") return interpn(self._points, self.lookup_table, inputs, method=self.method, bounds_error=self.bounds_error, fill_value=self.fill_value)
def build_OrographicRain_map(self, event, elev, inIDs): """ Build rain map using SMith & Barstad (2004) model for a given period and perform interpolation from regular grid to unstructured TIN one. Parameters ---------- float : event rain event number. float : elev Unstructured grid (TIN) Z coordinates. integer : inDs List of unstructured vertices contained in each partition. Return ---------- variable: tinRain Numpy array containing the updated rainfall for the local domain. """ # Interpolate elevation on regular grid distances, indices = self.tree.query(self.xyi, k=8) if len(elev[indices].shape) == 3: elev_vals = elev[indices][:,:,0] else: elev_vals = elev[indices] oelev = numpy.average(elev_vals,weights=(1./distances), axis=1) onIDs = numpy.where(distances[:,0] == 0)[0] if len(onIDs) > 0: oelev[onIDs] = elev[indices[onIDs,0]] oelev -= self.sealevel oelev = oelev.clip(0) regZ = numpy.reshape(oelev,(len(self.regX), len(self.regY)),order='F') # Use Smith & Barstad model rectRain = ORmodel.orographicrain.compute(regZ, self.dx, self.windx[event], self.windy[event], self.rmin[event], self.rmax[event], self.rbgd[event], self.nm[event], self.cw[event], self.hw[event], self.tauc[event], self.tauf[event]) # Apply smoothing here smthRain = gaussian_filter(rectRain, sigma=3) # Interpolate tinRain = interpolate.interpn( (self.regX, self.regY), smthRain, self.tXY[inIDs,:], method='linear') return tinRain
def downsample_axis(infile, outfile, axis, new_pixdim, method='linear'): """ Downsamples a volume along a specified axis. Inputs ------ infile : a filename from which to read data outfile : a filename to which to save data axis : the axis along which to downsample pixdim_ratio : the ratio by which to decrease pixdim. method : interpolation method ('linear' or 'nearest') """ if type(new_pixdim) is str: new_pixdim = ast.literal_eval(new_pixdim) if type(axis) is str: axis = ast.literal_eval(axis) from scipy.interpolate import interpn nii = nib.load(infile) hdr = nii.get_header() aff = nii.get_affine() data = nii.get_data().astype('float32') in_coords = [] out_coords = [] affine_modifier = np.eye(3) for ax in [0,1,2]: in_coords.append(np.arange(256)) if ax == axis: out_slice = slice(0, 252, new_pixdim) affine_modifier[ax,ax] = new_pixdim else: out_slice = slice(0, 256) out_coords.append(out_slice) out_grid = np.mgrid[out_coords].transpose(1,2,3,0) new_data = interpn(in_coords, data, out_grid, method=method, fill_value=None) hdr['pixdim'][1+axis] = new_pixdim # Multiply affine matrix by resampling matrix. # WARNING: no guarantees this'll work for non-axis-aligned images... aff[:3, :3] = np.dot(affine_modifier, aff[:3, :3]) #new_aff = np.vstack((np.dot(affine_modifier, aff[:-1,:]), aff[-1:,:])) out = nib.Nifti1Image(new_data.astype('uint8'), header=hdr.copy(), affine=aff) out.update_header() out.to_filename(outfile)
def load_Tecto_map(self, time, inIDs): """ Load vertical displacement map for a given period and perform interpolation from regular grid to unstructured TIN one. Parameters ---------- float : time Requested time interval rain map to load. integer : inDs List of unstructured vertices contained in each partition. Return ---------- variable: tinDisp Numpy array containing the updated displacement rate for the local domain. """ events = numpy.where( (self.T_disp[:,1] - time) <= 0)[0] event = len(events) if not (time >= self.T_disp[event,0]) and not (time < self.T_disp[event,1]): raise ValueError('Problem finding the displacements map to load!') self.next_disp = self.T_disp[event,1] if self.injected_disps is not None or self.Map_disp[event] != None: if self.injected_disps is not None: dispMap = self.injected_disps else: dispMap = pandas.read_csv(str(self.Map_disp[event]), sep=r'\s+', engine='c', header=None, na_filter=False, \ dtype=numpy.float, low_memory=False).values rectDisp = numpy.reshape(dispMap,(len(self.regX), len(self.regY)),order='F') tinDisp = interpolate.interpn( (self.regX, self.regY), rectDisp, self.tXY[inIDs,:], method='linear') dt = (self.T_disp[event,1] - self.T_disp[event,0]) if dt <= 0: raise ValueError('Problem computing the displacements rate for event %d.'%event) tinDisp = tinDisp / dt else: tinDisp = numpy.zeros(len(self.tXY[:,0]), dtype=float) return tinDisp
def lnlike(theta, spec, sn, mod, chigrid): mt, z, g, t = theta points = (mod.mt, mod.z, mod.g, mod.t) # Index the chisq grid # chi = bfobj.vchi chi = chigrid # Nearest neighbour chidx = [find_nearest(i, j) for i, j in zip(points, theta)] like_check = -(chi[chidx[0], chidx[1], chidx[2], chidx[3]])/2. # Interpolate the grid if like_check is np.ma.masked: like = -np.inf else: like = -(interpn(points, chi, theta, fill_value=np.inf))/2. if not np.isfinite(like) or np.abs(like) == 0.0: return -np.inf return np.sum(like)
def get_Rain(self, time, elev, inIDs): """ Get rain value for a given period and perform interpolation from regular grid to unstructured TIN one. Parameters ---------- float : time Requested time interval rain map to load. float : elev Unstructured grid (TIN) Z coordinates. integer : inDs List of unstructured vertices contained in each partition. Return ---------- variable: tinRain Numpy array containing the updated rainfall for the local domain. """ events = numpy.where( (self.T_rain[:,1] - time) <= 0)[0] event = len(events) if not (time >= self.T_rain[event,0]) and not (time < self.T_rain[event,1]): raise ValueError('Problem finding the rain map to load!') if self.orographic[event]: tinRain = self.build_OrographicRain_map(event, elev, inIDs) self.next_rain = min(time + self.ortime[event], self.T_rain[event,1]) elif self.Map_rain[event] == None: tinRain = numpy.zeros(len(self.tXY[inIDs,0]), dtype=float) tinRain = self.rainVal[event] self.next_rain = self.T_rain[event,1] else: rainMap = pandas.read_csv(str(self.Map_rain[event]), sep=r'\s+', engine='c', header=None, na_filter=False, dtype=numpy.float, low_memory=False) rectRain = numpy.reshape(rainMap.values,(len(self.regX), len(self.regY)),order='F') tinRain = interpolate.interpn( (self.regX, self.regY), rectRain, self.tXY[inIDs,:], method='linear') self.next_rain = self.T_rain[event,1] return tinRain
def interpolate(self, *vecs, **kwargs): """Interpolate the function at given points. The points are either provided as a large array with each row consisting of one point or as a tuple of vectors each defining one coordinate of the interpolation points. If `as_grid` is True, each combination of coordinates will be used (each point on the grid defined by the coordinates). Additional keyword args are passed to scipy.interpolate.interpn. TODO: write up properly""" as_grid = kwargs.get('as_grid', False) if as_grid: coo = Coord(*vecs) vecs = coo.asarr() method = kwargs.get('method', 'linear') bounds_error = kwargs.get('bounds_error', False) fill_value = kwargs.get('fill_value', 0.0) return interpn(self.coord.vecs, self.fvals, vecs, method=method, bounds_error=bounds_error, fill_value=fill_value)
def interp(self, shape, *args, **kwargs): """ Returns an interpolated version of the grid Parameters ---------- shape : int, array_like the new shape of the grid *args, **kwargs : optional arguments passed to the interpolation algorithm The interpolation routine is `scipy.interpolate.interpn` """ # Get current grid spacing dold = ( np.linspace(0, 1, self.shape[0]), np.linspace(0, 1, self.shape[1]), np.linspace(0, 1, self.shape[2]) ) # Interpolate from scipy.interpolate import interpn # Create new grid grid = self.__class__(shape, bc=np.copy(self.bc), sc=self.sc.copy()) # Clean-up to reduce memory del grid.grid # Create new mesh-grid dnew = np.vstack(np.meshgrid( np.linspace(0, 1, shape[0]), np.linspace(0, 1, shape[1]), np.linspace(0, 1, shape[2]))) dnew.shape = (-1, 3) grid.grid = interpn(dold, self.grid, dnew, *args, **kwargs) # immediately delete the dnew (which is VERY large) del dold, dnew # Ensure that the grid has the correct shape grid.grid.shape = tuple(shape) return grid
def __call__(self, mask_size, sigma): """ :param mask_size: size of mask in [mm] should depend on real size od :param sigma: sigma is a LoG parameter :return: kernel with new size depending on mask_size and spacing and new values """ pixel_size_of_mask = ceil(mask_size / self.spacing[0]) pixel_size_of_mask = pixel_size_of_mask + ((pixel_size_of_mask - 1) % 2) pixel_size_of_mask_z = ceil(mask_size / self.spacing[2]) pixel_size_of_mask_z = pixel_size_of_mask_z + ((pixel_size_of_mask_z - 1) % 2) # object for getting log with appropriate sigma self.LoG3D = LoG3D(sigma) LoG_kernel = self.LoG3D.get_LoG() self.x, self.y, self.z = self.LoG3D.get_grid_x_y_z() index_value = np.linspace(0, self.x.size - 1, pixel_size_of_mask).astype(dtype=np.int) index_value_z = np.linspace(0, self.x.size - 1, pixel_size_of_mask_z).astype(dtype=np.int) index_value[-1] = self.x.size - 1 max_value_index = np.unravel_index(LoG_kernel.argmax(), LoG_kernel.shape)[0] index_value_z[-1] = self.x.size - 1 max_value_index_z = np.unravel_index(LoG_kernel.argmax(), LoG_kernel.shape)[2] if not (max_value_index in index_value): index_value[-2] = max_value_index index_value.sort() if not (max_value_index_z in index_value_z): index_value_z[-2] = max_value_index_z index_value_z.sort() one = np.ones(pixel_size_of_mask_z).astype(dtype=np.int) list_end = [] for j in index_value: list_for_grid_temp = [] for i in index_value: list_for_grid_temp.append(np.array([one * self.x[j], one * self.y[i], self.z[index_value_z]]).T) list_end.append(list_for_grid_temp) interpolate_grid = np.array(list_end) print(interpolate_grid[1,0,0]) kernel = interpn((self.x, self.y, self.z), LoG_kernel, interpolate_grid)
def interp(self, in_data, inverse=False, fwd_pe=True): dshape = tuple(in_data.shape) gridxyz = self._fmapxyz.reshape((dshape[0], dshape[1], dshape[2], -1)) x = gridxyz[:, 0, 0, 0] y = gridxyz[0, :, 0, 1] z = gridxyz[0, 0, :, 2] targets = self._fmapxyz.copy() if inverse: factor = 1.0 if fwd_pe else -1.0 targets[:, self._pedir] += factor * \ self._inverted[tuple(self._fmapijk.T)] else: targets[:, self._pedir] += self._smoothed[tuple(self._fmapijk.T)] interpolated = np.zeros_like(self._data) interpolated[tuple(self._fmapijk.T)] = interpn( (x, y, z), in_data, [tuple(v) for v in targets], bounds_error=False, fill_value=0) return nb.Nifti1Image(interpolated, self._fmapnii.affine, self._fmapnii.header)
def interp_grid_to_spherical(grid, radii, num_phi, num_theta, grid_origin=(0,0,0), return_spherical_coords=False): """ Compute interpolated values in 3D spherical coordinates from a 3D square grid. The interpolated values lie equally spaced along the azumithal and polar directions for a series of concentric spheres. Interpolation used is linear. Parameters ---------- grid : np.ndarray, float The 3D square grid of values definiting a scalar field radii : np.ndarray, float The radial values of the interpolant grid num_theta : int The number of points along the polar angle to interpolate num_phi : int The number of points along the azmuthal angle to interpolate grid_origin : 3-tuple, floats The origin of the grid, which forms the center of the interpolant spheres Optional Parameters ------------------- return_spherical_coords : bool If true, the spherical coordiantes used are also returned as an N x 3 array. Returns ------- interpolated : np.ndarray A 3D array of the interpolated values. The dimensions are (radial, polar [theta], azmuthal [phi]). """ # find the cartesian x,y,z values for each interpolant xi = np.zeros( (len(radii) * num_theta * num_phi, 3), dtype=grid.dtype ) thetas = np.arange(0.0, 2.0*np.pi, 2.0*np.pi / num_theta) phis = np.arange(0.0, np.pi, np.pi / num_phi) assert len(thetas) == num_theta, 'thetas len mistmatch %d %d' % (len(thetas), num_theta) assert len(phis) == num_phi, 'phi len mistmatch %d %d' % (len(phis), num_phi) # the repeat rate will be important for the reshape, below r = np.repeat(radii, num_theta * num_phi) # radius, slowest t = np.repeat( np.tile(thetas, num_phi), len(radii)) # theta p = np.tile(phis, len(radii) * num_theta) # phi, fastest xi[:,0] = r * np.sin(t) * np.cos(p) # x xi[:,1] = r * np.sin(t) * np.sin(p) # y xi[:,2] = r * np.cos(t) # z xi += np.array(grid_origin)[None,:] # compute an interpolator for the rectangular grid gi = [ np.arange(l) for l in grid.shape ] interpolated = interpn(gi, grid, xi, bounds_error=False) res = interpolated.reshape(len(radii), num_theta, num_phi) if return_spherical_coords: rtp = np.array([r, t, p]) return res, rtp else: return res
def interpolation_handle(self, desired_coordinates): return si.interpn(tuple(self.input_data), self.output_data, desired_coordinates)
def load_Disp_map(self, time, tXY, inIDs, strata=False, sXY=None, insIDs=None): """ Load 3D displacements map for a given period and perform interpolation from regular grid to unstructured TIN one. Parameters ---------- float : time Requested time interval rain map to load. float : tXY Unstructured grid (TIN) XY coordinates. integer : inIDs List of unstructured vertices contained in each partition. boolean : strata Stratigraphic module flag. float : sXY Stratigraphic regular grid XY coordinates. integer : insIDs List of stratigraphic vertices contained in each partition. """ # Initialise MPI communications comm = mpi.COMM_WORLD rank = comm.Get_rank() size = comm.Get_size() self.tXY = tXY totPts = len(tXY[:,0]) dispX = numpy.zeros(totPts, dtype=float) dispY = numpy.zeros(totPts, dtype=float) dispZ = numpy.zeros(totPts, dtype=float) dpXY = tXY[inIDs,:] if strata: totsPts = len(sXY[:,0]) sdispX = numpy.zeros(totsPts, dtype=float) sdispY = numpy.zeros(totsPts, dtype=float) sdispZ = numpy.zeros(totsPts, dtype=float) dpsXY = sXY[insIDs,:] events = numpy.where( (self.T_disp[:,1] - time) <= 0)[0] event = len(events) if not (time >= self.T_disp[event,0]) and not (time < self.T_disp[event,1]): raise ValueError('Problem finding the 3D displacements map to load!') if self.time3d > 0.: if time + self.time3d > self.T_disp[event,1]: self.next_disp = self.T_disp[event,1] else: self.next_disp = self.time3d + time else: self.next_disp = self.T_disp[event,1] update = False if self.injected_disps is not None or self.Map_disp[event] != None: dispX.fill(-1.e6) dispY.fill(-1.e6) dispZ.fill(-1.e6) if self.injected_disps is not None: dvals = self.injected_disps else: disps = pandas.read_csv(str(self.Map_disp[event]), sep=r'\s+', engine='c', header=None, na_filter=False, \ dtype=numpy.float, low_memory=False) dvals = disps.values disprX = numpy.reshape(dvals[:,0],(len(self.regX), len(self.regY)),order='F') disprY = numpy.reshape(dvals[:,1],(len(self.regX), len(self.regY)),order='F') disprZ = numpy.reshape(dvals[:,2],(len(self.regX), len(self.regY)),order='F') dispX[inIDs] = interpolate.interpn( (self.regX, self.regY), disprX, dpXY, method='linear') dispY[inIDs] = interpolate.interpn( (self.regX, self.regY), disprY, dpXY, method='linear') dispZ[inIDs] = interpolate.interpn( (self.regX, self.regY), disprZ, dpXY, method='linear') comm.Allreduce(mpi.IN_PLACE, dispX, op=mpi.MAX) comm.Allreduce(mpi.IN_PLACE, dispY, op=mpi.MAX) comm.Allreduce(mpi.IN_PLACE, dispZ, op=mpi.MAX) update = True if strata: sdispX.fill(-1.e6) sdispY.fill(-1.e6) sdispX[insIDs] = interpolate.interpn( (self.regX, self.regY), disprX, dpsXY, method='linear') sdispY[insIDs] = interpolate.interpn( (self.regX, self.regY), disprY, dpsXY, method='linear') comm.Allreduce(mpi.IN_PLACE, sdispX, op=mpi.MAX) comm.Allreduce(mpi.IN_PLACE, sdispY, op=mpi.MAX) if self.time3d > 0. and (self.injected_disps is not None or self.Map_disp[event] != None): rate = (self.next_disp - time) / (self.T_disp[event,1] - self.T_disp[event,0]) assert rate > 0 dispX = dispX * rate dispY = dispY * rate dispZ = dispZ * rate if strata: sdispX = sdispX * rate sdispY = sdispY * rate self.dispX = dispX self.dispY = dispY self.dispZ = dispZ if strata: return update, sdispX, sdispY else: return update
#verts0, faces = pg.isosurface(absw,f_isovalue)#the verts are depending on ogrid index nor ogrid value verts0, faces = pg.isosurface(realwf,f_isovalue) verts1, facesm = pg.isosurface(realwf,-f_isovalue) #verts0, faces = pg.isosurface(absw,f_isovalue) #isophase0 = linterp3d(wphase,verts0) xx=numpy.linspace(0,50,51) yy=numpy.linspace(0,50,51) zz=numpy.linspace(0,50,51) from scipy.interpolate import griddata from scipy.interpolate import RegularGridInterpolator from scipy.interpolate import interpn #inter_function = griddata((xx,yy,zz),wphase) #isophase = griddata((xx,yy,zz),wphase,verts0,method='linear') #inter_function = RegularGridInterpolator((xx,yy,zz),wphase) isophase = interpn((xx,yy,zz),wphase,verts0,method = 'linear')#both RegularGridInterpolator and interpn can do the interpolation isophasem = interpn((xx,yy,zz),wphase,verts1,method = 'linear') #isophase = inter_function(verts0) #isophasem = inter_function(verts1) #numpy.savetxt('isop',isophase) verts = verts0*2-(50,50,50) N_vertices = int(verts.size/3) N_triangles = int(faces.size/3) N_isophase = int (isophase.size) vertsm = verts1*2-(50,50,50) N_verticesm = int(vertsm.size/3) N_trianglesm = int(facesm.size/3) N_isophasem = int (isophasem.size)
if z[it[i]] >= 1.3: oldpara[i][1] = 6.8e42 oldLF[i] = LF.LuminosityFunction(oldpara[i], lumHa[i]) grid = np.array([[0.0 for i in range(interpolatingSize)] for i in range(2)]) mpgrid = mpmath.arange( oldLF[oldLF < -5].max(), oldLF.max(), (oldLF.max() - oldLF[oldLF < -5].max()) / interpolatingSize ) grid[1] = np.ogrid[0 : 6 : interpolatingSize * 1j] newLF = np.array([[0.0 for i in range(interpolatingSize)] for i in range(interpolatingSize)]) for i in range(interpolatingSize): for j in range(interpolatingSize): newLF[i][j] = optimize.brentq( LF.rootfinding, 1e30, 1e50, args=(LF.luminosityParameterHa(grid[1][i]), mpgrid[j]) ) z = (z + 1) * (5007.0 / 6563.0) - 1 newLum = interpolate.interpn([grid[1], mpgrid], newLF, np.array([z[it], oldLF]).T, bounds_error=False, fill_value=0.0) for i in np.where(oldLF < -5)[0]: newLum[i] = optimize.brentq(LF.rootfinding, 1e30, 1e50, args=(LF.luminosityParameterHa(z[it][i]), oldLF[i])) z = (z + 1) * (6563.0 / 5007.0) - 1 Ha[it] = newLum / (4 * np.pi * (dl ** 2)) print "Calibrating OIIIb line" newLumO3b = [0.0 for x in range((it.shape[0]))] grid = np.array([[0.0 for i in range(interpolatingSize)] for i in range(2)]) mpgrid = mpmath.linspace(oldLF[oldLF < -2.7].max(), oldLF.max(), interpolatingSize) grid[1] = np.ogrid[0 : 6 : interpolatingSize * 1j] newLF = np.array([[0.0 for i in range(interpolatingSize)] for i in range(interpolatingSize)]) for i in range(interpolatingSize): for j in range(interpolatingSize): newLF[i][j] = optimize.brentq(