def ComputeJacobianMatrix(self, vec_x, vec_xi=None, rep_loc=None): #need validation """ Calcul l'inverse du Jacobien aux points de gauss dans le cas d'un élément isoparamétrique (c'est à dire que les mêmes fonctions de forme sont utilisées) vec_xi est un tableau dont les lignes donnent les coordonnées dans le repère de référence où on souhaite avoir le jacobien (en général pg) """ if vec_xi is None: vec_xi = self.xi_pg self.ComputeDetJacobian(vec_x, vec_xi) if rep_loc != None: rep_pg = self.interpolateLocalFrame( rep_loc, vec_xi) #interpolation du repère local aux points de gauss self.JacobianMatrix = sp.matmul( self.JacobianMatrix, sp.swapaxes(rep_pg, 2, 3) ) #to verify - sp.swapaxes(rep_pg,2,3) is equivalent to a transpose over the axis 2 and 3 # for k,J in enumerate(self.JacobianMatrix): self.JacobianMatrix[k] = sp.dot(J, rep_pg[k].T) if self.JacobianMatrix.shape[-2] == self.JacobianMatrix.shape[-1]: self.inverseJacobian = linalg.inv(self.JacobianMatrix) # self.inverseJacobian = [linalg.inv(J) for J in self.JacobianMatrix] else: #l'espace réel est dans une dimension plus grande que l'espace de l'élément de référence J = self.JacobianMatrix JT = sp.swapaxes(self.JacobianMatrix, 2, 3) self.inverseJacobian = sp.matmul( JT, linalg.inv(sp.matmul(J, JT)) ) #inverseJacobian.shape = (Nel,len(vec_xi)=nb_pg, dim:vec_x.shape[-1], dim:vec_xi.shape[-1])
def _update_images(self): """ Updates the image data in self.plotdata to correspond to the slices given. """ cube = self.colorcube pd = self.plotdata pdVoxel = self.plotdataVoxel pdVoxelFFT = self.plotdataVoxelFFT pdPC = self.plotdataPC # These are transposed because img_plot() expects its data to be in # row-major order pd.set_data("yz", sp.swapaxes(cube[self.slice_x, :, :],0,1)) pd.set_data("xz", sp.swapaxes(cube[:, self.slice_y, :],0,1)) pd.set_data("xy", cube[:,:,self.slice_z]) pdVoxel.set_data("TimeVoxel", self.Voxel) aTime = num.zeros(self.num_figs) aTime[:] = num.nan aTime[self.pos_t]= self.Voxel[self.pos_t] pdVoxel.set_data("time", aTime) pcTime = num.zeros(self.num_figs) pcTime[:] = num.nan pcTime[self.pos_t]= self.principalComponent[self.pos_t] pdPC.set_data("Principal Component",self.principalComponent) pdPC.set_data("time", pcTime) pdVoxelFFT.set_data("FreqVoxel",self.FFTVoxel) aFreq = num.zeros(self.frqs.shape) aFreq[:] = num.nan aFreq[list(self.maxtab[:,0])]= self.fftPeaks pdVoxelFFT.set_data("peaks", aFreq)
def align_image_with_openpnm(im): r""" Rotates an image to agree with the coordinates used in OpenPNM. It is unclear why they are not in agreement to start with. This is necessary for overlaying the image and the network in Paraview. Parameters ---------- im : ND-array The image to be rotated. Can be the Boolean image of the pore space or any other image of interest. Returns ------- image : ND-array Returns a copy of ``im`` rotated accordingly. """ im = sp.copy(im) if im.ndim == 2: im = (sp.swapaxes(im, 1, 0)) im = im[-1::-1, :] elif im.ndim == 3: im = (sp.swapaxes(im, 2, 0)) im = im[:, -1::-1, :] return im
def errfunc(pars, residuals=False): stat_tot = 0 #for i in range(len(table.field('MAG_' + magtype + '-' + complist[0][0][0])[:100])): #print i #print 'MAG_' + magtype + '-' + a #print a,b #print table.field('MAG_ISO-' + a) #print magtype, 'MAG_' + magtype + '-' + a if 1: A_zp = scipy.swapaxes( scipy.swapaxes( scipy.array(loci * [ stars_good * [[assign_zp(a[0][1], pars, zps) for a in complist]] ]), 0, 1), 0, 0) B_zp = scipy.swapaxes( scipy.swapaxes( scipy.array(loci * [ stars_good * [[assign_zp(a[1][1], pars, zps) for a in complist]] ]), 0, 1), 0, 0) colors_zp = A_zp - B_zp #print colors_zp.shape #print locus_matrix.shape #print colors.shape #print colors_zp[0][:][0] #print colors[2][0], colors.shape #print locus_matrix[2][0], locus_matrix.shape print colors_zp.shape, colors.shape, locus_matrix.shape ds_prelim = ((colors - locus_matrix - colors_zp)**2.) ds_prelim[good == 0] = 0. #print ds_prelim[2][0], 'ds_prelim' ds = (ds_prelim.sum(axis=2))**0.5 #print ds[2][0] ''' formula from High 2009 ''' dotprod = abs((colors - locus_matrix - colors_zp) * colors_err) dotprod[ good == 0] = 0. # set error to zero for poor measurements not in fit dotprod_sum = dotprod.sum(axis=2) sum_diff = ds**2. / dotprod_sum #sum_diff = ds / colors_err #print sum_diff[2], 'sum_diff' #print c_diff[2][0], 'c_diff' dist = ds.min(axis=1) select_diff = sum_diff.min(axis=1) #print select_diff, 'select_diff' #select_diff_norm = select_diff #/star_mag_num #print select_diff_norm, 'select_diff_norm' stat_tot = select_diff.sum() #print stat_tot, 'stat_tot' print pars, stat_tot #, zps print zps_list_full if residuals: return select_diff, dist else: return stat_tot
def plot(pars): A_zp = scipy.swapaxes(scipy.swapaxes(scipy.array(loci*[stars_good*[[assign_zp(a[0][1],pars,zps) for a in complist]]]),0,1),0,0) B_zp = scipy.swapaxes(scipy.swapaxes(scipy.array(loci*[stars_good*[[assign_zp(a[1][1],pars,zps) for a in complist]]]),0,1),0,0) colors_zp = A_zp- B_zp import pylab pylab.clf() for i in range(len(complist)): print complist[i], i x_color = scipy.array((colors - colors_zp)[:,0,2].tolist()) y_color = (colors - colors_zp)[:,0,0] x_err = (colors_err)[:,0,2] y_err = (colors_err)[:,0,0] x_color = x_color[x_err<100] y_color = y_color[x_err<100] y_err = y_err[x_err<100] x_err = x_err[x_err<100] x_color = x_color[y_err<100] y_color = y_color[y_err<100] x_err = x_err[y_err<100] y_err = y_err[y_err<100] print len(x_color), len(x_color) #raw_input() pylab.scatter(x_color,y_color) pylab.errorbar(x_color,y_color,xerr=x_err,yerr=y_err,fmt=None) pylab.scatter(locus_matrix[0,:,2],locus_matrix[0,:,0],color='red') pylab.show()
def align_image_with_openpnm(im): r""" Rotates an image to agree with the coordinates used in OpenPNM. It is unclear why they are not in agreement to start with. This is necessary for overlaying the image and the network in Paraview. Parameters ---------- im : ND-array The image to be rotated. Can be the Boolean image of the pore space or any other image of interest. Returns ------- image : ND-array Returns a copy of ``im`` rotated accordingly. """ if im.ndim != im.squeeze().ndim: warnings.warn('Input image conains a singleton axis:' + str(im.shape) + ' Reduce dimensionality with np.squeeze(im) to avoid' + ' unexpected behavior.') im = sp.copy(im) if im.ndim == 2: im = (sp.swapaxes(im, 1, 0)) im = im[-1::-1, :] elif im.ndim == 3: im = (sp.swapaxes(im, 2, 0)) im = im[:, -1::-1, :] return im
def watershed5(i_d, logger): # compute neighbourslocal_min = (filters.minimum_filter(arr, size=3)==arr) logger.info('Computing differences / edges...') nbs = compute_neighbours_max_border(i_d) # compute min altitude map logger.info('Computing minimal altitude map...') minaltitude = nbs[0] for nb in nbs[1:]: minaltitude = scipy.minimum(minaltitude, nb) logger.info('Swapping axes...') nbs = scipy.swapaxes(nbs, 0, 1) nbs = scipy.swapaxes(nbs, 1, 2) nbs = scipy.swapaxes(nbs, 2, 3) # compute relevant neighbours logger.info('Computing relevant neighbours...') neighbours = [] for x in range(i_d.shape[0]): x_list = [] neighbours.append(x_list) nbs_x = nbs[x] for y in range(i_d.shape[1]): y_list = [] x_list.append(y_list) nbs_y = nbs_x[y] for z in range(i_d.shape[2]): z_set = set() y_list.append(z_set) nbs_z = nbs_y[z] nbs_idx = get_nbs_idx3(( x, y, z)) # do not care about borders, their value is set to max min_value = minaltitude[x, y, z] for idx, nb in nbs_idx: if nbs_z[idx] == min_value: z_set.add(nb) # watershed logger.info( 'Watershed \w minaltitude and relevant neighbours as list pre-computation...' ) result = scipy.zeros(i_d.shape, dtype=scipy.uint16) nb_labs = 0 for x in range(result.shape[0]): for y in range(result.shape[1]): for z in range(result.shape[2]): if result[x, y, z] != 0: continue # 10% L, lab = stream_neighbours2_set(i_d, result, minaltitude, neighbours, (x, y, z)) # 90% if -1 == lab: nb_labs += 1 for p in L: result[p] = nb_labs else: for p in L: result[p] = lab return result
def ComputeJacobianMatrix(self, vec_x, vec_xi=None, rep_loc=None): if vec_xi is None: vec_xi == self.xi_pg self.ComputeDetJacobian(vec_x, vec_xi) if self.JacobianMatrix.shape[-2] == self.JacobianMatrix.shape[-1]: if rep_loc != None: rep_pg = self.interpolateLocalFrame( rep_loc, vec_xi ) #interpolation du repère local aux points de gauss -> shape = (len(vec_x),len(vec_xi),dim,dim) self.JacobianMatrix = sp.matmul( self.JacobianMatrix, sp.swapaxes(rep_pg, 2, 3) ) #to verify - sp.swapaxes(rep_pg,2,3) is equivalent to a transpose over the axis 2 and 3 # rep_pg = self.interpolateLocalFrame(rep_loc, vec_xi) #interpolation du repère local aux points de gauss # for k,J in enumerate(self.JacobianMatrix): self.JacobianMatrix[k] = sp.dot(J, rep_pg[k].T) else: #l'espace réel est dans une dimension plus grande que l'espace de l'élément de référence if rep_loc is None: J = self.JacobianMatrix JT = sp.swapaxes(self.JacobianMatrix, 2, 3) self.inverseJacobian = sp.matmul( JT, linalg.inv(sp.matmul(J, JT)) ) #inverseJacobian.shape = (Nel,len(vec_xi)=nb_pg, dim:vec_x.shape[-1], dim:vec_xi.shape[-1]) # self.inverseJacobian = [sp.dot(J.T , linalg.inv(sp.dot(J,J.T))) for J in self.JacobianMatrix] #this line may have a high computational cost return else: rep_pg = self.repLocFromJac(rep_loc, vec_xi)[:, 0:2, :] for k, J in enumerate(self.JacobianMatrix): self.JacobianMatrix[k] = sp.dot(J, rep_pg[k].T) self.inverseJacobian = linalg.inv(self.JacobianMatrix)
def _update_images(self): """ Updates the image data in self.plotdata to correspond to the slices given. """ cube = self.colorcube pd = self.plotdata pdVoxel = self.plotdataVoxel pdVoxelFFT = self.plotdataVoxelFFT pdPC = self.plotdataPC # These are transposed because img_plot() expects its data to be in # row-major order pd.set_data("yz", sp.swapaxes(cube[self.slice_x, :, :], 0, 1)) pd.set_data("xz", sp.swapaxes(cube[:, self.slice_y, :], 0, 1)) pd.set_data("xy", cube[:, :, self.slice_z]) pdVoxel.set_data("TimeVoxel", self.Voxel) aTime = num.zeros(self.num_figs) aTime[:] = num.nan aTime[self.pos_t] = self.Voxel[self.pos_t] pdVoxel.set_data("time", aTime) pcTime = num.zeros(self.num_figs) pcTime[:] = num.nan pcTime[self.pos_t] = self.principalComponent[self.pos_t] pdPC.set_data("Principal Component", self.principalComponent) pdPC.set_data("time", pcTime) pdVoxelFFT.set_data("FreqVoxel", self.FFTVoxel) aFreq = num.zeros(self.frqs.shape) aFreq[:] = num.nan aFreq[list(self.maxtab[:, 0])] = self.fftPeaks pdVoxelFFT.set_data("peaks", aFreq)
def watershed5(i_d, logger): # compute neighbourslocal_min = (filters.minimum_filter(arr, size=3)==arr) logger.info('Computing differences / edges...') nbs = compute_neighbours_max_border(i_d) # compute min altitude map logger.info('Computing minimal altitude map...') minaltitude = nbs[0] for nb in nbs[1:]: minaltitude = scipy.minimum(minaltitude, nb) logger.info('Swapping axes...') nbs = scipy.swapaxes(nbs, 0, 1) nbs = scipy.swapaxes(nbs, 1, 2) nbs = scipy.swapaxes(nbs, 2, 3) # compute relevant neighbours logger.info('Computing relevant neighbours...') neighbours = [] for x in range(i_d.shape[0]): x_list = [] neighbours.append(x_list) nbs_x = nbs[x] for y in range(i_d.shape[1]): y_list = [] x_list.append(y_list) nbs_y = nbs_x[y] for z in range(i_d.shape[2]): z_set = set() y_list.append(z_set) nbs_z = nbs_y[z] nbs_idx = get_nbs_idx3((x,y,z)) # do not care about borders, their value is set to max min_value = minaltitude[x, y, z] for idx, nb in nbs_idx: if nbs_z[idx] == min_value: z_set.add(nb) # watershed logger.info('Watershed \w minaltitude and relevant neighbours as list pre-computation...') result = scipy.zeros(i_d.shape, dtype=scipy.uint16) nb_labs = 0 for x in range(result.shape[0]): for y in range(result.shape[1]): for z in range(result.shape[2]): if result[x,y,z] != 0: continue # 10% L, lab = stream_neighbours2_set(i_d, result, minaltitude, neighbours, (x, y, z)) # 90% if -1 == lab: nb_labs += 1 for p in L: result[p] = nb_labs else: for p in L: result[p] = lab return result
def test(path='lines_test_dat.sav', PEC=None, E_thresh=1.0, He_source='PEC'): sf = scipy.io.readsav(path) r = scipy.asarray(sf['rad'], dtype=float) / 100.0 q_IDL = scipy.asarray(sf['emhead'][:, 1], dtype=int) - 1 lam_IDL = scipy.asarray(sf['emhead'][:, 2], dtype=float) / 10.0 E_IDL = h * c / (lam_IDL * 1e-9 * e * 1e3) ne = scipy.asarray(sf['nelec'], dtype=float) # already in cm^-3 Te = scipy.asarray(sf['te'], dtype=float) # already in keV em_IDL = scipy.swapaxes(scipy.asarray(sf['lemist'], dtype=float), 1, 2) * 1e6 # convert to ph/s/m^3 cs_den = scipy.swapaxes(scipy.asarray(sf['denst'], dtype=float), 1, 2) # already in cm^-3 atdata_IDL = read_atdata(path='atdata.dat.original')[20] comment_IDL = [l.comment for l in atdata_IDL] # comment_IDL = [str(typ) for typ in sf['emhead'][:, 3]] em, lam, E, q, comment = compute_lines( 20, cs_den, ne, Te, PEC=PEC, E_thresh=E_thresh, He_source=He_source, full_return=True ) t = range(0, em.shape[0]) plot_lines(em, E, q, comment, t, r) plot_lines(em_IDL, E_IDL, q_IDL, comment_IDL, t, r) atdata = read_atdata() sindat = read_sindat() filter_trans = read_filter_file('Be_filter_50_um.dat')(E) with open('Be_50_um_{src:s}.pkl'.format(src=He_source), 'wb') as f: pkl.dump(filter_trans, f) emiss = compute_SXR(cs_den, ne, Te, atdata, sindat, filter_trans, PEC, He_source=He_source) f = plt.figure() a_ne = f.add_subplot(3, 1, 1) a_ne.plot(r, ne) a_ne.set_ylabel('$n_e$ [cm^-3]') a_Te = f.add_subplot(3, 1, 2) a_Te.plot(r, Te) a_Te.set_ylabel('$T_e$ [keV]') a_emiss = f.add_subplot(3, 1, 3) a_emiss.plot(r, emiss[0, :]) a_emiss.set_ylabel('$\epsilon$ [W/m^3]') a_emiss.set_xlabel('$r$ [m]') return em, E, q, comment, emiss
def read_lsm(path,color=False): """ takes a path to a lsm file, reads the file with the tifffile lib and returns a np array final format is of the array dims: x y t - if color is True: x y t c """ data = tifffile.imread(path) Data_cut = data[0,0,:,:,:] # empirical ... Data_cut_rot = sp.swapaxes(Data_cut,0,2) if color: # Thorough testing if xy order is preserved is missing! Data_cut = data[0,:,:,:] Data_cut_rot = sp.swapaxes(Data_cut,2,0) Data_cut_rot = sp.swapaxes(Data_cut_rot,1,3) return Data_cut_rot
def test_partial_dot_mat_mat(self): mat1 = sp.asarray(self.mat) mat1.shape = (4, 3, 2, 5) mat1 = matrix.make_mat(mat1, axis_names=('time', 'x', 'y', 'z'), row_axes=(0, ), col_axes=(1, 2, 3)) mat2 = sp.asarray(self.mat) mat2.shape = (4, 2, 3, 5) mat2 = matrix.make_mat(mat2, axis_names=('w', 'y', 'x', 'freq'), row_axes=(0, 1, 2), col_axes=(3, )) result = dot_products.partial_dot(mat1, mat2) self.assertEqual(result.axes, ('time', 'w', 'z', 'freq')) self.assertEqual(result.rows, (0, 1)) self.assertEqual(result.cols, (2, 3)) self.assertEqual(result.shape, (4, 4, 5, 5)) right_ans = sp.tensordot(mat1, mat2, ((1, 2), (2, 1))) right_ans = sp.swapaxes(right_ans, 1, 2) self.assertTrue(sp.allclose(right_ans, result))
def read_lsm(path,color=False): """ takes a path to a lsm file, reads the file with the tifffile io and returns a np array final format is of the array dims: x y t - if color is True: x y t c """ data = tifffile.imread(path) Data_cut = data[0,0,:,:,:] # empirical ... Data_cut_rot = sp.swapaxes(Data_cut,0,2) if color: # Thorough testing if xy order is preserved is missing! Data_cut = data[0,:,:,:] Data_cut_rot = sp.swapaxes(Data_cut,2,0) Data_cut_rot = sp.swapaxes(Data_cut_rot,1,3) return Data_cut_rot
def interleave(lst): """Given a list of arrays, interleave the arrays in a way that the first dimension represents the first dimension of every array. This is useful for time series, where multiple time series should be processed in a single swipe.""" arr = scipy.asarray(lst) return scipy.swapaxes(arr, 0, 1)
def main(): args = getArguments(getParser()) # prepare logger logger = Logger.getInstance() if args.debug: logger.setLevel(logging.DEBUG) elif args.verbose: logger.setLevel(logging.INFO) # load input image data_input, header_input = load(args.input) logger.debug('Original shape = {}.'.format(data_input.shape)) # check if supplied dimension parameters is inside the images dimensions if args.dimension1 >= data_input.ndim or args.dimension1 < 0: raise ArgumentError('The first swap-dimension {} exceeds the number of input volume dimensions {}.'.format(args.dimension1, data_input.ndim)) elif args.dimension2 >= data_input.ndim or args.dimension2 < 0: raise ArgumentError('The second swap-dimension {} exceeds the number of input volume dimensions {}.'.format(args.dimension2, data_input.ndim)) # swap axes data_output = scipy.swapaxes(data_input, args.dimension1, args.dimension2) # swap pixel spacing and offset ps = list(header.get_pixel_spacing(header_input)) ps[args.dimension1], ps[args.dimension2] = ps[args.dimension2], ps[args.dimension1] header.set_pixel_spacing(header_input, ps) os = list(header.get_offset(header_input)) os[args.dimension1], os[args.dimension2] = os[args.dimension2], os[args.dimension1] header.set_offset(header_input, os) logger.debug('Resulting shape = {}.'.format(data_output.shape)) # save resulting volume save(data_output, args.output, header_input, args.force) logger.info("Successfully terminated.")
def f(self, x): N = self.xdim / 3 coords = x.reshape((N, 3)) distances = sqrt( scipy.sum((tile(coords, (N, 1, 1)) - swapaxes(tile(coords, (N, 1, 1)), 0, 1))**2, axis=2)) + eye(N) return 2 * sum(ravel(distances**-12 - distances**-6))
def main(): # parse cmd arguments parser = getParser() parser.parse_args() args = getArguments(parser) # prepare logger logger = Logger.getInstance() if args.debug: logger.setLevel(logging.DEBUG) elif args.verbose: logger.setLevel(logging.INFO) # load first input image as example example_data, example_header = load(args.inputs[0]) # test if the supplied position is valid if args.position > example_data.ndim or args.position < 0: raise ArgumentError( 'The supplied position for the new dimension is invalid. It has to be between 0 and {}.' .format(example_data.ndim)) # prepare empty output volume output_data = scipy.zeros([len(args.inputs)] + list(example_data.shape), dtype=example_data.dtype) # add first image to output volume output_data[0] = example_data # load input images and add to output volume for idx, image in enumerate(args.inputs[1:]): image_data, _ = load(image) if not args.ignore and image_data.dtype != example_data.dtype: raise ArgumentError( 'The dtype {} of image {} differs from the one of the first image {}, which is {}.' .format(image_data.dtype, image, args.inputs[0], example_data.dtype)) if image_data.shape != example_data.shape: raise ArgumentError( 'The shape {} of image {} differs from the one of the first image {}, which is {}.' .format(image_data.shape, image, args.inputs[0], example_data.shape)) output_data[idx + 1] = image_data # move new dimension to the end or to target position for dim in range(output_data.ndim - 1): if dim >= args.position: break output_data = scipy.swapaxes(output_data, dim, dim + 1) # set pixel spacing spacing = list(header.get_pixel_spacing(example_header)) spacing = tuple(spacing[:args.position] + [args.spacing] + spacing[args.position:]) example_header.set_voxel_spacing(spacing) # save created volume save(output_data, args.output, example_header, args.force) logger.info("Successfully terminated.")
def sliceEpsArr(EpsArr,NX,NY,NZ,figNum): """ Visualizing object with slices """ vxyR=sci.real(EpsArr[:,:,round(NZ/2.0)]) vxzR=sci.real(EpsArr[:,round(NY/2.0),:]) vyzR=sci.real(EpsArr[round(NX/2.0),:,:]) vxyI=sci.imag(EpsArr[:,:,round(NZ/2.0)]) vxzI=sci.imag(EpsArr[:,round(NY/2.0),:]) vyzI=sci.imag(EpsArr[round(NX/2.0),:,:]) plt.ion() fig=plt.figure(figNum) fig.clear() plt.subplot(231) plt.imshow(vxyR) plt.title('real($\\varepsilon$), xy-plane') plt.colorbar() plt.subplot(232) plt.imshow(sci.swapaxes(vxzR,0,1)) plt.title('real($\\varepsilon$), xz-plane') plt.colorbar() plt.subplot(233) plt.imshow(sci.swapaxes(vyzR,0,1)) plt.title('real($\\varepsilon$), yz-plane') plt.colorbar() plt.subplot(234) plt.imshow(vxyI) plt.title('imag($\\varepsilon$), xy-plane') plt.colorbar() plt.subplot(235) plt.imshow(sci.swapaxes(vxzI,0,1)) plt.title('imag($\\varepsilon$), xz-plane') plt.colorbar() plt.subplot(236) plt.imshow(sci.swapaxes(vyzI,0,1)) plt.title('imag($\\varepsilon$), yz-plane') plt.colorbar() fig.canvas.draw() plt.ioff() return
def sliceEpsArr(EpsArr, NX, NY, NZ, figNum): """ Visualizing object with slices """ vxyR = sci.real(EpsArr[:, :, round(NZ / 2.0)]) vxzR = sci.real(EpsArr[:, round(NY / 2.0), :]) vyzR = sci.real(EpsArr[round(NX / 2.0), :, :]) vxyI = sci.imag(EpsArr[:, :, round(NZ / 2.0)]) vxzI = sci.imag(EpsArr[:, round(NY / 2.0), :]) vyzI = sci.imag(EpsArr[round(NX / 2.0), :, :]) plt.ion() fig = plt.figure(figNum) fig.clear() plt.subplot(231) plt.imshow(vxyR) plt.title('real($\\varepsilon$), xy-plane') plt.colorbar() plt.subplot(232) plt.imshow(sci.swapaxes(vxzR, 0, 1)) plt.title('real($\\varepsilon$), xz-plane') plt.colorbar() plt.subplot(233) plt.imshow(sci.swapaxes(vyzR, 0, 1)) plt.title('real($\\varepsilon$), yz-plane') plt.colorbar() plt.subplot(234) plt.imshow(vxyI) plt.title('imag($\\varepsilon$), xy-plane') plt.colorbar() plt.subplot(235) plt.imshow(sci.swapaxes(vxzI, 0, 1)) plt.title('imag($\\varepsilon$), xz-plane') plt.colorbar() plt.subplot(236) plt.imshow(sci.swapaxes(vyzI, 0, 1)) plt.title('imag($\\varepsilon$), yz-plane') plt.colorbar() fig.canvas.draw() plt.ioff() return
def main(): args = getArguments(getParser()) # prepare logger logger = Logger.getInstance() if args.debug: logger.setLevel(logging.DEBUG) elif args.verbose: logger.setLevel(logging.INFO) # load dicom slices [series] = pydicom_series.read_files( args.input, False, True) # second to not show progress bar, third to retrieve data #print series.sampling # Note: The first value is the mean of all differences between ImagePositionPatient-values of the DICOM slices - of course total bullshit data_3d = series.get_pixel_array() # check parameters if args.dimension >= data_3d.ndim or args.dimension < 0: raise ArgumentError( 'The image has only {} dimensions. The supplied target dimension {} exceeds this number.' .format(data_3d.ndim, args.dimension)) if not 0 == data_3d.shape[args.dimension] % args.offset: raise ArgumentError( 'The number of slices {} in the target dimension {} of the image shape {} is not dividable by the supplied number of consecutive slices {}.' .format(data_3d.shape[args.dimension], args.dimension, data_3d.shape, args.offset)) # prepare empty target volume volumes_3d = data_3d.shape[args.dimension] / args.offset shape_4d = list(data_3d.shape) shape_4d[args.dimension] = volumes_3d data_4d = scipy.zeros([args.offset] + shape_4d, dtype=data_3d.dtype) logger.debug( 'Separating {} slices into {} 3D volumes of thickness {}.'.format( data_3d.shape[args.dimension], volumes_3d, args.offset)) # iterate over 3D image and create sub volumes which are then added to the 4d volume for idx in range(args.offset): # collect the slices for sl in range(volumes_3d): idx_from = [slice(None), slice(None), slice(None)] idx_from[args.dimension] = slice(idx + sl * args.offset, idx + sl * args.offset + 1) idx_to = [slice(None), slice(None), slice(None)] idx_to[args.dimension] = slice(sl, sl + 1) #print 'Slice {} to {}.'.format(idx_from, idx_to) data_4d[idx][idx_to] = data_3d[idx_from] # flip dimensions such that the newly created is the last data_4d = scipy.swapaxes(data_4d, 0, 3) # save resulting 4D volume save(data_4d, args.output, False, args.force) logger.info("Successfully terminated.")
def main(): # parse cmd arguments parser = getParser() parser.parse_args() args = getArguments(parser) # prepare logger logger = Logger.getInstance() if args.debug: logger.setLevel(logging.DEBUG) elif args.verbose: logger.setLevel(logging.INFO) # load first input image as example example_data, example_header = load(args.inputs[0]) # test if the supplied position is valid if args.position > example_data.ndim or args.position < 0: raise ArgumentError('The supplied position for the new dimension is invalid. It has to be between 0 and {}.'.format(example_data.ndim)) # prepare empty output volume output_data = scipy.zeros([len(args.inputs)] + list(example_data.shape), dtype=example_data.dtype) # add first image to output volume output_data[0] = example_data # load input images and add to output volume for idx, image in enumerate(args.inputs[1:]): image_data, _ = load(image) if not args.ignore and image_data.dtype != example_data.dtype: raise ArgumentError('The dtype {} of image {} differs from the one of the first image {}, which is {}.'.format(image_data.dtype, image, args.inputs[0], example_data.dtype)) if image_data.shape != example_data.shape: raise ArgumentError('The shape {} of image {} differs from the one of the first image {}, which is {}.'.format(image_data.shape, image, args.inputs[0], example_data.shape)) output_data[idx + 1] = image_data # move new dimension to the end or to target position for dim in range(output_data.ndim - 1): if dim >= args.position: break output_data = scipy.swapaxes(output_data, dim, dim + 1) # set pixel spacing spacing = list(header.get_pixel_spacing(example_header)) spacing = tuple(spacing[:args.position] + [args.spacing] + spacing[args.position:]) # !TODO: Find a way to enable this also for PyDicom and ITK images if __is_header_nibabel(example_header): __update_header_from_array_nibabel(example_header, output_data) header.set_pixel_spacing(example_header, spacing) else: raise ArgumentError("Sorry. Setting the voxel spacing of the new dimension only works with NIfTI images. See the description of this program for more details.") # save created volume save(output_data, args.output, example_header, args.force) logger.info("Successfully terminated.")
def main(): args = getArguments(getParser()) # prepare logger logger = Logger.getInstance() if args.debug: logger.setLevel(logging.DEBUG) elif args.verbose: logger.setLevel(logging.INFO) # load 3d image data_3d, header_3d = load(args.input) # check if supplied dimension parameter is inside the images dimensions if args.dimension >= data_3d.ndim or args.dimension < 0: raise ArgumentError( 'The supplied cut-dimension {} exceeds the number of input volume dimensions {}.' .format(args.dimension, data_3d.ndim)) # check if the supplied offset parameter is a divider of the cut-dimensions slice number if not 0 == data_3d.shape[args.dimension] % args.offset: raise ArgumentError( 'The offset is not a divider of the number of slices in cut dimension ({} / {}).' .format(data_3d.shape[args.dimension], args.offset)) # prepare empty target volume volumes_3d = data_3d.shape[args.dimension] / args.offset shape_4d = list(data_3d.shape) shape_4d[args.dimension] = volumes_3d data_4d = scipy.zeros([args.offset] + shape_4d, dtype=data_3d.dtype) logger.debug( 'Separating {} slices into {} 3D volumes of thickness {}.'.format( data_3d.shape[args.dimension], volumes_3d, args.offset)) # iterate over 3D image and create sub volumes which are then added to the 4d volume for idx in range(args.offset): # collect the slices for sl in range(volumes_3d): idx_from = [slice(None), slice(None), slice(None)] idx_from[args.dimension] = slice(idx + sl * args.offset, idx + sl * args.offset + 1) idx_to = [slice(None), slice(None), slice(None)] idx_to[args.dimension] = slice(sl, sl + 1) #print 'Slice {} to {}.'.format(idx_from, idx_to) data_4d[idx][idx_to] = data_3d[idx_from] # flip dimensions such that the newly created is the last data_4d = scipy.swapaxes(data_4d, 0, args.dimension + 1) data_4d = scipy.rollaxis(data_4d, 0, 4) # save resulting 4D volume save(data_4d, args.output, header_3d, args.force) logger.info("Successfully terminated.")
def main(): args = getArguments(getParser()) # prepare logger logger = Logger.getInstance() if args.debug: logger.setLevel(logging.DEBUG) elif args.verbose: logger.setLevel(logging.INFO) # load dicom slices [series] = pydicom_series.read_files(args.input, False, True) # second to not show progress bar, third to retrieve data #print series.sampling # Note: The first value is the mean of all differences between ImagePositionPatient-values of the DICOM slices - of course total bullshit data_3d = series.get_pixel_array() # check parameters if args.dimension >= data_3d.ndim or args.dimension < 0: raise ArgumentError('The image has only {} dimensions. The supplied target dimension {} exceeds this number.'.format( data_3d.ndim, args.dimension)) if not 0 == data_3d.shape[args.dimension] % args.offset: raise ArgumentError('The number of slices {} in the target dimension {} of the image shape {} is not dividable by the supplied number of consecutive slices {}.'.format( data_3d.shape[args.dimension], args.dimension, data_3d.shape, args.offset)) # prepare empty target volume volumes_3d = data_3d.shape[args.dimension] / args.offset shape_4d = list(data_3d.shape) shape_4d[args.dimension] = volumes_3d data_4d = scipy.zeros([args.offset] + shape_4d, dtype=data_3d.dtype) logger.debug('Separating {} slices into {} 3D volumes of thickness {}.'.format(data_3d.shape[args.dimension], volumes_3d, args.offset)) # iterate over 3D image and create sub volumes which are then added to the 4d volume for idx in range(args.offset): # collect the slices for sl in range(volumes_3d): idx_from = [slice(None), slice(None), slice(None)] idx_from[args.dimension] = slice(idx + sl * args.offset, idx + sl * args.offset + 1) idx_to = [slice(None), slice(None), slice(None)] idx_to[args.dimension] = slice(sl, sl+1) #print 'Slice {} to {}.'.format(idx_from, idx_to) data_4d[idx][idx_to] = data_3d[idx_from] # flip dimensions such that the newly created is the last data_4d = scipy.swapaxes(data_4d, 0, 3) # save resulting 4D volume save(data_4d, args.output, False, args.force) logger.info("Successfully terminated.")
def sliceFieldArr(Ein, NX, NY, NZ, SliceX, SliceY, SliceZ, figNum, fieldName): """ Visualizing field with slices """ vxy1 = Ein[:, :, SliceZ, 0] vxy2 = Ein[:, :, SliceZ, 1] vxy3 = Ein[:, :, SliceZ, 2] vyz1 = Ein[SliceX, :, :, 0] vyz2 = Ein[SliceX, :, :, 1] vyz3 = Ein[SliceX, :, :, 2] vxz1 = Ein[:, SliceY, :, 0] vxz2 = Ein[:, SliceY, :, 1] vxz3 = Ein[:, SliceY, :, 2] plt.ion() fig = plt.figure(figNum) fig.clear() plt.subplot(331) plt.imshow(sci.real(vxy1)) plt.title('real($' + fieldName + '_{x}$), xy-plane') plt.colorbar() plt.subplot(332) plt.imshow(sci.real(sci.swapaxes(vxz1, 0, 1))) plt.title('real($' + fieldName + '_{x}$), xz-plane') plt.colorbar() plt.subplot(333) plt.imshow(sci.real(sci.swapaxes(vyz1, 0, 1))) plt.title('real($' + fieldName + '_{x}$), yz-plane') plt.colorbar() plt.subplot(334) plt.imshow(sci.real(vxy2)) plt.title('real($' + fieldName + '_{y}$), xy-plane') plt.colorbar() plt.subplot(335) plt.imshow(sci.real(sci.swapaxes(vxz2, 0, 1))) plt.title('real($' + fieldName + '_{y}$), xz-plane') plt.colorbar() plt.subplot(336) plt.imshow(sci.real(sci.swapaxes(vyz2, 0, 1))) plt.title('real($' + fieldName + '_{y}$), yz-plane') plt.colorbar() plt.subplot(337) plt.imshow(sci.real(vxy3)) plt.title('real($' + fieldName + '_{z}$), xy-plane') plt.colorbar() plt.subplot(338) plt.imshow(sci.real(sci.swapaxes(vxz3, 0, 1))) plt.title('real($' + fieldName + '_{z}$), xz-plane') plt.colorbar() plt.subplot(339) plt.imshow(sci.real(sci.swapaxes(vyz3, 0, 1))) plt.title('real($' + fieldName + '_{z}$), yz-plane') plt.colorbar() fig.canvas.draw() plt.ioff() return
def sliceFieldArr(Ein,NX,NY,NZ,SliceX,SliceY,SliceZ,figNum,fieldName): """ Visualizing field with slices """ vxy1=Ein[:,:,SliceZ,0] vxy2=Ein[:,:,SliceZ,1] vxy3=Ein[:,:,SliceZ,2] vyz1=Ein[SliceX,:,:,0] vyz2=Ein[SliceX,:,:,1] vyz3=Ein[SliceX,:,:,2] vxz1=Ein[:,SliceY,:,0] vxz2=Ein[:,SliceY,:,1] vxz3=Ein[:,SliceY,:,2] plt.ion() fig=plt.figure(figNum) fig.clear() plt.subplot(331) plt.imshow(sci.real(vxy1)) plt.title('real($'+fieldName+'_{x}$), xy-plane') plt.colorbar() plt.subplot(332) plt.imshow(sci.real(sci.swapaxes(vxz1,0,1))) plt.title('real($'+fieldName+'_{x}$), xz-plane') plt.colorbar() plt.subplot(333) plt.imshow(sci.real(sci.swapaxes(vyz1,0,1))) plt.title('real($'+fieldName+'_{x}$), yz-plane') plt.colorbar() plt.subplot(334) plt.imshow(sci.real(vxy2)) plt.title('real($'+fieldName+'_{y}$), xy-plane') plt.colorbar() plt.subplot(335) plt.imshow(sci.real(sci.swapaxes(vxz2,0,1))) plt.title('real($'+fieldName+'_{y}$), xz-plane') plt.colorbar() plt.subplot(336) plt.imshow(sci.real(sci.swapaxes(vyz2,0,1))) plt.title('real($'+fieldName+'_{y}$), yz-plane') plt.colorbar() plt.subplot(337) plt.imshow(sci.real(vxy3)) plt.title('real($'+fieldName+'_{z}$), xy-plane') plt.colorbar() plt.subplot(338) plt.imshow(sci.real(sci.swapaxes(vxz3,0,1))) plt.title('real($'+fieldName+'_{z}$), xz-plane') plt.colorbar() plt.subplot(339) plt.imshow(sci.real(sci.swapaxes(vyz3,0,1))) plt.title('real($'+fieldName+'_{z}$), yz-plane') plt.colorbar() fig.canvas.draw() plt.ioff() return
def main(): args = getArguments(getParser()) # prepare logger logger = Logger.getInstance() if args.debug: logger.setLevel(logging.DEBUG) elif args.verbose: logger.setLevel(logging.INFO) data_3d, _ = load(args.input) # check parameters if args.dimension >= data_3d.ndim or args.dimension < 0: raise ArgumentError('The image has only {} dimensions. The supplied target dimension {} exceeds this number.'.format( data_3d.ndim, args.dimension)) if not 0 == data_3d.shape[args.dimension] % args.offset: raise ArgumentError('The number of slices {} in the target dimension {} of the image shape {} is not dividable by the supplied number of consecutive slices {}.'.format( data_3d.shape[args.dimension], args.dimension, data_3d.shape, args.offset)) # prepare empty target volume volumes_3d = data_3d.shape[args.dimension] / args.offset shape_4d = list(data_3d.shape) shape_4d[args.dimension] = volumes_3d data_4d = scipy.zeros([args.offset] + shape_4d, dtype=data_3d.dtype) logger.debug('Separating {} slices into {} 3D volumes of thickness {}.'.format(data_3d.shape[args.dimension], volumes_3d, args.offset)) # iterate over 3D image and create sub volumes which are then added to the 4d volume for idx in range(args.offset): # collect the slices for sl in range(volumes_3d): idx_from = [slice(None), slice(None), slice(None)] idx_from[args.dimension] = slice(idx + sl * args.offset, idx + sl * args.offset + 1) idx_to = [slice(None), slice(None), slice(None)] idx_to[args.dimension] = slice(sl, sl+1) #print 'Slice {} to {}.'.format(idx_from, idx_to) data_4d[idx][idx_to] = data_3d[idx_from] # flip dimensions such that the newly created is the last data_4d = scipy.swapaxes(data_4d, 0, 3) # save resulting 4D volume save(data_4d, args.output, False, args.force) logger.info("Successfully terminated.")
def rescaleImage(self): '''Rescales image according to parameters in accompanying text file. File is the filename(without extension), data is the data matrix and nbvals is the amount of b-values. Does not return anything because this modifies the array.''' if self.dim == 3: for i in range(self.shape[3]): self.pdata[:, :, :, i] = self.pdata[:, :, :, i] * self.slopes[i] elif self.dim == 2: rslopes = np.reshape(self.slopes, self.shape[:-3:-1]) rslopes = scipy.swapaxes(rslopes, 0, 1) for j in range(self.shape[2]): for i in range(self.shape[3]): self.pdata[:, :, j, i] = self.pdata[:, :, j, i] * rslopes[j, i] else: print "No b-values found or cannot process slope formatting."
def main(): args = getArguments(getParser()) # prepare logger logger = Logger.getInstance() if args.debug: logger.setLevel(logging.DEBUG) elif args.verbose: logger.setLevel(logging.INFO) # load 3d image data_3d, header_3d = load(args.input) # check if supplied dimension parameter is inside the images dimensions if args.dimension >= data_3d.ndim or args.dimension < 0: raise ArgumentError('The supplied cut-dimension {} exceeds the number of input volume dimensions {}.'.format(args.dimension, data_3d.ndim)) # check if the supplied offset parameter is a divider of the cut-dimensions slice number if not 0 == data_3d.shape[args.dimension] % args.offset: raise ArgumentError('The offset is not a divider of the number of slices in cut dimension ({} / {}).'.format(data_3d.shape[args.dimension], args.offset)) # prepare empty target volume volumes_3d = data_3d.shape[args.dimension] / args.offset shape_4d = list(data_3d.shape) shape_4d[args.dimension] = volumes_3d data_4d = scipy.zeros([args.offset] + shape_4d, dtype=data_3d.dtype) logger.debug('Separating {} slices into {} 3D volumes of thickness {}.'.format(data_3d.shape[args.dimension], volumes_3d, args.offset)) # iterate over 3D image and create sub volumes which are then added to the 4d volume for idx in range(args.offset): # collect the slices for sl in range(volumes_3d): idx_from = [slice(None), slice(None), slice(None)] idx_from[args.dimension] = slice(idx + sl * args.offset, idx + sl * args.offset + 1) idx_to = [slice(None), slice(None), slice(None)] idx_to[args.dimension] = slice(sl, sl+1) #print 'Slice {} to {}.'.format(idx_from, idx_to) data_4d[idx][idx_to] = data_3d[idx_from] # flip dimensions such that the newly created is the last data_4d = scipy.swapaxes(data_4d, 0, args.dimension + 1) data_4d = scipy.rollaxis(data_4d, 0, 4) # save resulting 4D volume save(data_4d, args.output, header_3d, args.force) logger.info("Successfully terminated.")
def test_partial_dot_mat_mat(self): mat1 = sp.asarray(self.mat) mat1.shape = (4, 3, 2, 5) mat1 = algebra.make_mat(mat1, axis_names=('time', 'x', 'y', 'z'), row_axes=(0,), col_axes=(1, 2, 3)) mat2 = sp.asarray(self.mat) mat2.shape = (4, 2, 3, 5) mat2 = algebra.make_mat(mat2, axis_names=('w', 'y', 'x', 'freq'), row_axes=(0, 1, 2), col_axes=(3,)) result = algebra.partial_dot(mat1, mat2) self.assertEqual(result.axes, ('time', 'w', 'z', 'freq')) self.assertEqual(result.rows, (0, 1)) self.assertEqual(result.cols, (2, 3)) self.assertEqual(result.shape, (4, 4, 5, 5)) right_ans = sp.tensordot(mat1, mat2, ((1, 2), (2, 1))) right_ans = sp.swapaxes(right_ans, 1, 2) self.assertTrue(sp.allclose(right_ans, result))
def rescaleImage(file, data, nbvals, dims): '''Rescales image according to parameters in accompanying text file. File is the filename(without extension), data is the data matrix and nbvals is the amount of b-values. Does not return anything because this modifies the array.''' slopes = np.array(list_values(read_line('VisuCoreDataSlope=', file))) if len(dims) == 3: for i in range(data.shape[3]): data[:, :, :, i] = data[:, :, :, i] * slopes[i] elif len(dims) == 2: rslopes = np.reshape(slopes, data.shape[:-3:-1]) rslopes = scipy.swapaxes(rslopes, 0, 1) for j in range(data.shape[2]): for i in range(data.shape[3]): data[:, :, j, i] = data[:, :, j, i] * rslopes[j, i] else: print "No b-values found or cannot process slope formatting."
def main(): args = getArguments(getParser()) # prepare logger logger = Logger.getInstance() if args.debug: logger.setLevel(logging.DEBUG) elif args.verbose: logger.setLevel(logging.INFO) # load input image data_input, header_input = load(args.input) logger.debug('Original shape = {}.'.format(data_input.shape)) # check if supplied dimension parameters is inside the images dimensions if args.dimension1 >= data_input.ndim or args.dimension1 < 0: raise ArgumentError( 'The first swap-dimension {} exceeds the number of input volume dimensions {}.' .format(args.dimension1, data_input.ndim)) elif args.dimension2 >= data_input.ndim or args.dimension2 < 0: raise ArgumentError( 'The second swap-dimension {} exceeds the number of input volume dimensions {}.' .format(args.dimension2, data_input.ndim)) # swap axes data_output = scipy.swapaxes(data_input, args.dimension1, args.dimension2) # swap pixel spacing and offset ps = list(header.get_pixel_spacing(header_input)) ps[args.dimension1], ps[args.dimension2] = ps[args.dimension2], ps[ args.dimension1] header.set_pixel_spacing(header_input, ps) os = list(header.get_offset(header_input)) os[args.dimension1], os[args.dimension2] = os[args.dimension2], os[ args.dimension1] header.set_offset(header_input, os) logger.debug('Resulting shape = {}.'.format(data_output.shape)) # save resulting volume save(data_output, args.output, header_input, args.force) logger.info("Successfully terminated.")
def read(file_name, map_inds=None, feedback=2): """Read a map from an image fits file. """ fname_abbr = ku.abbreviate_file_path(file_name) if feedback > 0: print "Opening file: " + fname_abbr # Open the fits file. hdulist = pyfits.open(file_name) history = bf.get_history_header(hdulist[0].header) history.add("Read from file.", "File name: " + fname_abbr) map_list = [] if map_inds is None: map_inds = range(1, len(hdulist)) elif not hasattr(map_inds, "__iter__"): map_inds = (map_inds,) elif len(scans) == 0: map_inds = range(1, len(hdulist)) for ii in map_inds: data = hdulist[ii].data # Set the data attriute Map = data_map.DataMap() Map.set_data(sp.swapaxes(data, 0, 2)) # Masked data is stored in FITS files as float('nan') Map.data[sp.logical_not(sp.isfinite(Map.data))] = ma.masked Map.history = history # Set the other fields. for field_name in fields: if not field_name in hdulist[1].header.keys(): continue value = hdulist[1].header[field_name] Map.set_field(field_name, value) map_list.append(Map) if len(map_list) == 1: map_list = map_list[0] return map_list
def read(file_name, map_inds=None, feedback=2): """Read a map from an image fits file. """ fname_abbr = ku.abbreviate_file_path(file_name) if feedback > 0: print 'Opening file: ' + fname_abbr # Open the fits file. hdulist = pyfits.open(file_name) history = bf.get_history_header(hdulist[0].header) history.add('Read from file.', 'File name: ' + fname_abbr) map_list = [] if map_inds is None: map_inds = range(1, len(hdulist)) elif not hasattr(map_inds, '__iter__'): map_inds = (map_inds, ) elif len(scans) == 0: map_inds = range(1, len(hdulist)) for ii in map_inds: data = hdulist[ii].data # Set the data attriute Map = data_map.DataMap() Map.set_data(sp.swapaxes(data, 0, 2)) # Masked data is stored in FITS files as float('nan') Map.data[sp.logical_not(sp.isfinite(Map.data))] = ma.masked Map.history = history # Set the other fields. for field_name in fields: if not field_name in hdulist[1].header.keys(): continue value = hdulist[1].header[field_name] Map.set_field(field_name, value) map_list.append(Map) if len(map_list) == 1: map_list = map_list[0] return map_list
def write(Maps, file_name, feedback=2): """Write a map to fits file. Map should be a map_data.MapData object. """ # If only a single Map was passed, make it iterable. if not hasattr(Maps, '__iter__'): Maps = (Maps, ) # First create a primary with the history and such: prihdu = pyfits.PrimaryHDU() # Add history to the primary. fname_abbr = ku.abbreviate_file_path(file_name) # Add final history entry and store in the primary header. history = base_data.merge_histories(*Maps) history.add('Written to file.', 'File name: ' + fname_abbr) bf.write_history_header(prihdu.header, history) list_of_hdus = [prihdu] for ii, Map in enumerate(Maps): # Creat an image HDU. map = sp.array(ma.filled(Map.data, float('nan'))) imhdu = pyfits.ImageHDU(sp.swapaxes(map, 0, 2), name='MAP%d' % ii) # Add extra data to the HDU for key in Map.field.iterkeys(): if Map.field_axes[key] != (): raise ce.DataError('Only 0D data can be written to a Fits Map ' 'Header.') card = pyfits.Card(key, Map.field[key].item()) imhdu.header.ascardlist().append(card) list_of_hdus.append(imhdu) # Creat the HDU list and write to file. hdulist = pyfits.HDUList(list_of_hdus) hdulist.writeto(file_name, clobber=True) if feedback > 0: print 'Wrote data to file: ' + fname_abbr
def write(Maps, file_name, feedback=2): """Write a map to fits file. Map should be a map_data.MapData object. """ # If only a single Map was passed, make it iterable. if not hasattr(Maps, "__iter__"): Maps = (Maps,) # First create a primary with the history and such: prihdu = pyfits.PrimaryHDU() # Add history to the primary. fname_abbr = ku.abbreviate_file_path(file_name) # Add final history entry and store in the primary header. history = base_data.merge_histories(*Maps) history.add("Written to file.", "File name: " + fname_abbr) bf.write_history_header(prihdu.header, history) list_of_hdus = [prihdu] for ii, Map in enumerate(Maps): # Creat an image HDU. map = sp.array(ma.filled(Map.data, float("nan"))) imhdu = pyfits.ImageHDU(sp.swapaxes(map, 0, 2), name="MAP%d" % ii) # Add extra data to the HDU for key in Map.field.iterkeys(): if Map.field_axes[key] != (): raise ce.DataError("Only 0D data can be written to a Fits Map " "Header.") card = pyfits.Card(key, Map.field[key].item()) imhdu.header.ascardlist().append(card) list_of_hdus.append(imhdu) # Creat the HDU list and write to file. hdulist = pyfits.HDUList(list_of_hdus) hdulist.writeto(file_name, clobber=True) if feedback > 0: print "Wrote data to file: " + fname_abbr
def plot_people(ifig, dom, people, contacts, U, colors, time=-1, axis=None, plot_people=True, plot_contacts=True, plot_velocities=True, plot_paths=False, paths=None, plot_sensors=False, sensors=[], savefig=False, filename='fig.png', cmap='winter'): """ This function draws spheres for the individuals, \ lines for the active contacts and arrows for the \ (desired or real) velocities. Parameters ---------- ifig: int figure number dom: Domain contains everything for managing the domain people: numpy array people coordinates and radius : x,y,r contacts: numpy array all the contacts : i,j,dij,eij_x,eij_y U: numpy array people velocities colors: numpy array scalar field used to define people colors time: float time in seconds axis: numpy array matplotlib axis : [xmin, xmax, ymin, ymax] plot_people: boolean draws spheres for people if true plot_paths: boolean draws people paths if true paths: numpy array coordinates of the people paths plot_sensors: boolean draws sensor lines if true sensors: numpy array sensor line coordinates (see also the sensor function below) savefig: boolean writes the figure as a png file if true filename: string png filename used to write the figure cmap: string matplotlib colormap name """ fig = plt.figure(ifig) plt.clf() ax1 = fig.add_subplot(111) # Domain ax1.imshow(dom.image, interpolation='nearest', extent=[dom.xmin, dom.xmax, dom.ymin, dom.ymax], origin='lower') if (plot_people): # People #offsets = list(zip(people[:,:2])) ## for older versions of matplotlib... offsets = people[:, :2] ec = EllipseCollection(widths=2 * people[:, 2], heights=2 * people[:, 2], angles=0, units='xy', cmap=plt.get_cmap(cmap), offsets=offsets, transOffset=ax1.transData) ec.set_array(colors) ax1.add_collection(ec) if (plot_contacts): # Contacts Nc = contacts.shape[0] if (Nc > 0): for ic in sp.arange(Nc): i = sp.int64(contacts[ic, 0]) j = sp.int64(contacts[ic, 1]) if (j != -1): line = Line2D([people[i, 0], people[j, 0]], [people[i, 1], people[j, 1]], lw=1., alpha=0.6, color='k') else: line = Line2D([ people[i, 0], people[i, 0] - (people[i, 2] + contacts[ic, 2]) * contacts[ic, 3] ], [ people[i, 1], people[i, 1] - (people[i, 2] + contacts[ic, 2]) * contacts[ic, 4] ], lw=1., alpha=0.6, color='k') ax1.add_line(line) if (plot_velocities): # Velocities Np = people.shape[0] for ip in sp.arange(Np): arrow = Arrow(people[ip, 0], people[ip, 1], U[ip, 0], U[ip, 1], width=0.3) ax1.add_patch(arrow) if ((plot_paths) and (paths is not None)): mpaths = sp.ma.masked_values(paths, 1e99) pathlines = [] for id in sp.arange(paths.shape[0]): pathlines.append(sp.swapaxes(mpaths[id, :, :], 0, 1)) pathlinecoll = LineCollection(pathlines, linewidths=0.5, linestyle="solid", cmap=plt.get_cmap(cmap)) pathlinecoll.set_array(colors) ax1.add_collection(pathlinecoll) if (plot_sensors): # Sensors for ss in sensors: line = Line2D([ss[0], ss[2]], [ss[1], ss[3]], lw=1., alpha=0.6, color='g') ax1.add_line(line) if (axis): ax1.set_xlim(axis[0], axis[1]) ax1.set_ylim(axis[2], axis[3]) ax1.set_xticks([]) ax1.set_yticks([]) ax1.axis('off') if (time >= 0): ax1.set_title('time = {:.2F}'.format(time) + ' s') fig.canvas.draw() if (savefig): fig.savefig(filename, dpi=600, bbox_inches='tight', pad_inches=0)
CalBlocks = () # Loop over IFs and read in the appropriate cal data. for Data in Blocks : CalT = data_block.DataBlock() for field in required_fields : CalT.set_field(field, Data.field[field], Data.field_axes[field], Data.field_formats[field]) CalT.set_field('CAL', ['R'], ('cal',), '1A') CalT.set_field('CRVAL4', [-5, -6], ('pol',), '1I') CalT.set_field('LST', [3546.2], ('time',), '1D') freq_centre = int(round(Data.field['CRVAL1']/1.0e6)) # MHz indata_xx = sp.loadtxt(input_root + str(freq_centre) + '_xx.txt') indata_yy = sp.loadtxt(input_root + str(freq_centre) + '_yy.txt') cal_data = sp.concatenate((indata_xx[:,[1]], indata_yy[:,[1]]), axis=1) cal_data = sp.swapaxes(cal_data, 0, 1) CalT.set_data(cal_data[sp.newaxis,:,sp.newaxis,:]) CalT.verify() CalBlocks = CalBlocks + (CalT,) BigData = stitch_windows_crude.stitch(CalBlocks) Writer.add_data(BigData) Writer.write(out_file)
def f(self, x): N = self.xdim / 3 coords = x.reshape((N, 3)) distances = sqrt(scipy.sum((tile(coords, (N, 1, 1)) - swapaxes(tile(coords, (N, 1, 1)), 0, 1)) ** 2, axis=2)) + eye(N) return 2 * sum(ravel(distances ** -12 - distances ** -6))
def Example1(): a = sp.array([[1,2,3],[4,5,6]]) b = sp.array([i*i for i in range(100) if i%2==1]) c = b.tolist() print a,b,c a = sp.zeros(100) # a 100-element array of float zeros b = sp.zeros((2,8), int) # a 2x8 array of int zeros c = sp.zeros((2,2,2), complex) # a NxMxL array of complex zeros print a,b,c a = sp.ones(10, int) # a 10-element array of int ones b = sp.pi * sp.ones((5,5)) # a useful way to fill up an array with a specified value print a,b id = sp.eye(10,10, dtype=int) # 10x10 identity matrix (1's on diagonal) offdiag = sp.eye(10,10,1)+sp.eye(10,10,-1) # off diagonal elements = 1 print id,offdiag a = sp.array([[1,2,3],[4,5,6]]) b = sp.transpose(a) # reverse dimensions of a (even for dim > 2) b = a.T # equivalent to scipy.transpose(a) c = sp.swapaxes(a, 0, 1) # swap specified axes print a,b,c a = sp.arange(1, 10, 1) # like Python range, but with (potentially) real-valued arrays b = sp.linspace(1, 10, 11) # create array of equally-spaced points based on specifed number of points print a,b a = sp.random.random((100,100)) # 100x100 array of floats uniform on [0.,1.) b = sp.random.randint(0,10, (100,)) # 100 random ints uniform on [0, 10), i.e., not including the upper bound 10 c = sp.random.standard_normal((5,5,5)) # zero-mean, unit-variance Gaussian random numbers in a 5x5x5 array print a,b,c elem = c[1,1,1] # equiv. to a[i][j][k] but presumably more efficient print elem i = sp.array([0,1,2,1]) # array of indices for the first axis j = sp.array([1,2,3,4]) # array of indices for the second axis print a[i,j] # return array([a[0,1], a[1,2], a[2,3], a[1,4]]) c = sp.linspace(1, 10, 11) b = sp.array([True, False, True, False]) print c[b] last_elem = c[-1] # the last element of the array print last_elem section = a[10:20, 30:40] # 10x10 subblock starting at [10,30] print section asection = a[10:, 30:] # missing stop index implies until end of array bsection = a[:10, :30] # missing start index implies until start of array print asection,bsection x = a[:, 0] # get everything in the 0th column (missing start and stop) y = a[:, 1] # get everything in the 1st column print x,y s = sp.sum(a) # sum all elements in a, returning a scalar s0 = sp.sum(a, axis=0) # sum elements along specified axis (=0), returning an array of remaining shape, e.g., a = sp.ones((10,20,30)) a0 = sp.sum(a, axis=0) # s0 has shape (20,30) print s,s0,a,a0 a = sp.array([[1,2,3],[4,5,6]]) m = sp.mean(a, axis=0) # compute mean along the specified axis (over entire array if axis=None) s = sp.std(a, axis=0) # compute standard deviation along the specified axis (over entire array if axis=None) print m,s s0 = sp.cumsum(a, axis=0) # cumulatively sum over 0 axis, returning array with same shape as a s1 = sp.cumsum(a) # cumulatively sum over 0 axis, returning 1D array of length shape[0]*shape[1]*...*shape[dim-1] print s0,s1
if len(ls)!=5: continue i = ls[0] j = ls[1] fit = ls[2] Temperature[i,j] = fit[0] Denscol[i,j] = fit[2] Turbvel[i,j] = fit[1] tau0[i,j] = ls[-1] model[i,j] = ls[-2] # Parameter error (confidence intervals) errmodel= sp.array(errmodel) model = sp.array(model) model = sp.swapaxes(model, 0,1) model = sp.swapaxes(model,0,2) print('Calculated Fits') model = sp.nan_to_num(model) dust = sp.nan_to_num(dust) Denscol = sp.nan_to_num(Denscol) Turbvel = sp.nan_to_num(Turbvel) Temperature = sp.nan_to_num(Temperature) tau0 = sp.nan_to_num(tau0) if Convolve: Denscol = Convolv(Denscol, head) Temperature = Convolv(Temperature, head) Turbvel = Convolv(Turbvel, head) mom2 = Convolv(mom2, head)
import lmdb import argparse import sys sys.path.insert(0, "/home/ogaki/Workspace/caffe/python") import caffe import cv2 import scipy parser = argparse.ArgumentParser() parser.add_argument("db") parser.add_argument("kvfile") parser.add_argument("imgdir") args = parser.parse_args() db = lmdb.open(path=args.db, map_size=1024 * 1024 * 1024) db.open_db() with db.begin(write=True) as buf: for i, line in enumerate(open(args.kvfile)): if i % 10000 == 0: print >> sys.stderr, i key = line.split()[0] imgfilepath = line.split()[1] #img = cv2.imread(args.imgdir+"/"+imgfilepath).transpose([2,0,1]) img = caffe.io.load_image(args.imgdir + "/" + imgfilepath).astype(float) img = scipy.swapaxes(img, 0, 2) datum = caffe.io.array_to_datum(img) buf.put(key, datum.SerializeToString())
def fit(combo, mapping, magtype, startingzps=None): filt_combo = [[mapping[c],c] for c in combo] good_fs = dict(filt_combo) filt_combo = [[mapping[c],'yes'] for c in combo] l_fs = dict(filt_combo) filt_combo = [[mapping[c],[c]] for c in combo] locus_dict_obj = dict(filt_combo) #good_fs = {'USDSS':'u','GSDSS':'g','RSDSS':'r','ISDSS':'i','ZSDSS':'z','JTMASS':'J'} #l_fs = {'USDSS':'yes','GSDSS':'yes','RSDSS':'yes','ISDSS':'yes','ZSDSS':'yes','JTMASS':'yes'} #locus_dict_obj = {'USDSS':['u'],'GSDSS':['g'],'RSDSS':['r'],'ISDSS':['i'],'ZSDSS':['z'],'JTMASS':['J']} #zp_dict = {'USDSS':0.,'GSDSS':0.,'RSDSS':0.,'ISDSS':0.,'ZSDSS':0.,'JTMASS':0.} #good_fs = {'JTMASS':'J','RSDSS':'r','ISDSS':'i',} #l_fs = {'JTMASS':'yes','RSDSS':'yes','ISDSS':'yes'} #locus_dict_obj = {'JTMASS':['J'],'RSDSS':['r'],'ISDSS':['i'],} import cutout_bpz, string locus_c = cutout_bpz.locus() print filter(lambda x:string.find(x.split('_')[0],'SDSS')!=-1 and string.find(x.split('_')[1],'SDSS')!=-1,locus_c.keys()) print filter(lambda x:string.find(x,'MASS')!=-1 and string.find(x,'SDSS')!=-1 ,locus_c.keys()) import re good_fs = [] for k1 in locus_c.keys(): res = re.split('_',k1) print l_fs print res if l_fs.has_key(res[0]) and l_fs.has_key(res[1]): good_fs.append([res[0],res[1]]) print l_fs print locus_dict_obj, good_fs print good_fs zps_dict_obj = {} list = ['MPUSUBARU','VJOHN','RJOHN'] #,'RJOHN','IJOHN','WSZSUBARU','WSISUBARU'] print good_fs complist = [] for f1A,f1B in good_fs: if f1A != 'MPUSUBARU' and f1B != 'MPUSUBARU': # True: #filter(lambda x: x==f1A, list) and filter(lambda x: x==f1B, list): zps_dict_obj[f1A] = 0 zps_dict_obj[f1B] = 0 import random for a in locus_dict_obj[f1A]: for b in locus_dict_obj[f1B]: complist.append([[a,f1A],[b,f1B]]) print complist print good_fs print zps_dict_obj print complist, 'complist' zps_list_full = combo #zps_dict_obj.keys() #if 'JTMASS' in zps_list_full: # zps_list_full = ['JTMASS'] + filter(lambda x: x!='JTMASS',zps_list_full) zps_list = zps_list_full[1:] zps ={} zps_rev ={} for i in range(len(zps_list)): zps[zps_list[i]] = i zps_rev[i] = zps_list[i] import pyfits p = pyfits.open('stars.fits')[1].data table = p loci = len(locus_c['GSDSS_RSDSS']) print loci stars = len(table.field('MAG_' + magtype + '_' + complist[0][0][0])) locus_list = [] for j in range(len(locus_c['GSDSS_RSDSS'])): o = [] for c in complist: #print c, len(locus_c[c[0][1] + '_' + c[1][1]]), j o.append(locus_c[c[0][1] + '_' + c[1][1]][j]) locus_list.append(o) import scipy results = {} for iteration in ['full','bootstrap1','bootstrap2','bootstrap3','bootstrap4']: ''' make matrix with a locus for each star ''' locus_matrix = scipy.array(stars*[locus_list]) print locus_matrix.shape ''' assemble matricies to make colors ''' A_band = scipy.swapaxes(scipy.swapaxes(scipy.array(loci*[[table.field('MAG_' + magtype + '_' + a[0][0]) for a in complist]]),0,2),1,2) B_band = scipy.swapaxes(scipy.swapaxes(scipy.array(loci*[[table.field('MAG_' + magtype + '_' + a[1][0]) for a in complist]]),0,2),1,2) A_err = scipy.swapaxes(scipy.swapaxes(scipy.array(loci*[[table.field('MAGERR_' + magtype + '_' + a[0][0]) for a in complist]]),0,2),1,2) B_err = scipy.swapaxes(scipy.swapaxes(scipy.array(loci*[[table.field('MAGERR_' + magtype + '_' + a[1][0]) for a in complist]]),0,2),1,2) print A_err.shape A_band[A_err > 1.] = -99 B_band[B_err > 1.] = -99 ''' make matrix specifying good values ''' good = scipy.ones(A_band.shape) good[A_band == -99] = 0 good[B_band == -99] = 0 good = good[:,0,:] good_test = good.sum(axis=1) # sum all of the good measurements for any given star print sorted(good_test) print good_test ''' figure out the cut-off ''' cut_off = 2 #sorted(good_test)[-20] -1 print cut_off A_band = A_band[good_test>cut_off] B_band = B_band[good_test>cut_off] A_err = A_err[good_test>cut_off] B_err = B_err[good_test>cut_off] A_err[A_err<0.05] = 0.05 B_err[B_err<0.05] = 0.05 locus_matrix = locus_matrix[good_test>cut_off] if string.find(iteration,'bootstrap') != -1: length = len(A_band) randvec = scipy.array([random.random() for ww in range(length)]) fraction = 0.5 mask = randvec < (fraction) A_band = A_band[mask] B_band = B_band[mask] A_err = A_err[mask] B_err = B_err[mask] locus_matrix = locus_matrix[mask] colors = A_band - B_band colors_err = (A_err**2. + B_err**2.)**0.5 colors_err[A_band == -99] = 1000000. colors_err[B_band == -99] = 1000000. colors_err[A_band == 99] = 1000000. colors_err[B_band == 99] = 1000000. colors[A_band == -99] = 0. colors[B_band == -99] = 0. colors[A_band == 99] = 0. colors[B_band == 99] = 0. print colors.shape, locus_matrix.shape from copy import copy print good_test #colors = colors[good_test > 1] #colors_err = colors_err[good_test > 1] #locus_matrix = locus_matrix[good_test > 1] stars_good = len(locus_matrix) good = scipy.ones(A_band.shape) good[A_band == -99] = 0 good[B_band == -99] = 0 print good.sum(axis=2).sum(axis=1).sum(axis=0) #good = good[:,0,:] good_test = good[:,0,:].sum(axis=1) good = good[good_test > 1] star_mag_num = good[:,0,:].sum(axis=1) itr = 0 def errfunc(pars,residuals=False): stat_tot = 0 #for i in range(len(table.field('MAG_' + magtype + '-' + complist[0][0][0])[:100])): #print i #print 'MAG_' + magtype + '-' + a #print a,b #print table.field('MAG_ISO-' + a) #print magtype, 'MAG_' + magtype + '-' + a if 1: A_zp = scipy.swapaxes(scipy.swapaxes(scipy.array(loci*[stars_good*[[assign_zp(a[0][1],pars,zps) for a in complist]]]),0,1),0,0) B_zp = scipy.swapaxes(scipy.swapaxes(scipy.array(loci*[stars_good*[[assign_zp(a[1][1],pars,zps) for a in complist]]]),0,1),0,0) colors_zp = A_zp- B_zp #print colors_zp.shape #print locus_matrix.shape #print colors.shape #print colors_zp[0][:][0] #print colors[2][0], colors.shape #print locus_matrix[2][0], locus_matrix.shape print colors_zp.shape, colors.shape, locus_matrix.shape ds_prelim = ((colors - locus_matrix - colors_zp)**2.) ds_prelim[good == 0] = 0. #print ds_prelim[2][0], 'ds_prelim' ds = (ds_prelim.sum(axis=2))**0.5 #print ds[2][0] ''' formula from High 2009 ''' dotprod = abs((colors - locus_matrix - colors_zp) * colors_err) dotprod[good == 0] = 0. # set error to zero for poor measurements not in fit dotprod_sum = dotprod.sum(axis=2) sum_diff = ds**2./dotprod_sum #sum_diff = ds / colors_err #print sum_diff[2], 'sum_diff' #print c_diff[2][0], 'c_diff' dist = ds.min(axis=1) select_diff = sum_diff.min(axis=1) #print select_diff, 'select_diff' #select_diff_norm = select_diff #/star_mag_num #print select_diff_norm, 'select_diff_norm' stat_tot = select_diff.sum() #print stat_tot, 'stat_tot' print pars, stat_tot#, zps print zps_list_full if residuals: return select_diff, dist else: return stat_tot import pylab #pylab.ion() def plot(pars): A_zp = scipy.swapaxes(scipy.swapaxes(scipy.array(loci*[stars_good*[[assign_zp(a[0][1],pars,zps) for a in complist]]]),0,1),0,0) B_zp = scipy.swapaxes(scipy.swapaxes(scipy.array(loci*[stars_good*[[assign_zp(a[1][1],pars,zps) for a in complist]]]),0,1),0,0) colors_zp = A_zp- B_zp import pylab pylab.clf() for i in range(len(complist)): print complist[i], i x_color = scipy.array((colors - colors_zp)[:,0,2].tolist()) y_color = (colors - colors_zp)[:,0,0] x_err = (colors_err)[:,0,2] y_err = (colors_err)[:,0,0] x_color = x_color[x_err<100] y_color = y_color[x_err<100] y_err = y_err[x_err<100] x_err = x_err[x_err<100] x_color = x_color[y_err<100] y_color = y_color[y_err<100] x_err = x_err[y_err<100] y_err = y_err[y_err<100] print len(x_color), len(x_color) #raw_input() pylab.scatter(x_color,y_color) pylab.errorbar(x_color,y_color,xerr=x_err,yerr=y_err,fmt=None) pylab.scatter(locus_matrix[0,:,2],locus_matrix[0,:,0],color='red') pylab.show() ''' now rerun after cutting outliers ''' if True: if iteration == 'full': if startingzps is None: pinit = scipy.zeros(len(zps_list)) else: pinit = [startingzps[key] for key in zps_list] else: import random ''' add random offset of 1.0 mag ''' pinit = [results['full'][key] + random.random()*1.0 for key in zps_list] #plot(pinit) from scipy import optimize out = scipy.optimize.fmin(errfunc,pinit,maxiter=100000,args=()) print out #plot(out) import scipy print zps_list print 'starting' print out residuals,dist = errfunc(pars=[0.] + out,residuals=True) print dist.shape, residuals.shape raw_input() print dist print 'finished' print 'colors' , len(colors) ''' first filter on distance ''' colors = colors[dist < 1] colors_err = colors_err[dist < 1] locus_matrix = locus_matrix[dist < 1] good = good[dist < 1] residuals = residuals[dist < 1] ''' filter on residuals ''' colors = colors[residuals < 6] colors_err = colors_err[residuals < 6] locus_matrix = locus_matrix[residuals < 6] good = good[residuals < 6] stars_good = len(locus_matrix) star_mag_num = good[:,0,:].sum(axis=1) print 'colors' , len(colors) pinit = out #scipy.zeros(len(zps_list)) from scipy import optimize out = scipy.optimize.fmin(errfunc,pinit,args=()) print out #plot(out) results[iteration] = dict(zip(zps_list_full,([0.] + out.tolist()))) print results errors = {} import scipy print 'BOOTSTRAPPING ERRORS:' for key in zps_list_full: l = [] for r in results.keys(): if r != 'full': l.append(results[r][key]) print key+':', scipy.std(l), 'mag' errors[key] = scipy.std(l) if False: def save_results(save_file,results,errors): f = open(save_file,'w') for key in results['full'].keys(): f.write(key + ' ' + str(results['full'][key]) + ' +- ' + str(errors[key]) + '\n') f.close() import pickle f = open(save_file + '.pickle','w') m = pickle.Pickler(f) pickle.dump({'results':results,'errors':errors},m) f.close() if results.has_key('full') and save_results is not None: save_results(save_file,results, errors) return results
def plot_people_paths(ifig, dt, pixel_size, people, domain, results, axis=None, savefig=False, filename='fig.png'): """ To draw all the individual paths from intial time to final time Parameters ---------- ifig: int figure number dt: float time step pixel_size: float size of one pixel in meters people: numpy masked arrays equal to 1 if the cell (i,j) is occupied, 0 elsewhere domain: Domain contains everything for managing the domain results: numpy array positions at each time axis: list matplotlib axis savefig: boolean writes the figure as a png file if true filename: string png filename used to write the figure """ Np = results.shape[0] fig = plt.figure(ifig) fig.clf() ax1 = fig.add_subplot(111) ax1.imshow(domain.image, interpolation='nearest', extent=[domain.xmin, domain.xmax, domain.ymin, domain.ymax], origin='lower') I0 = results[:, 0, 0] J0 = results[:, 1, 0] exit_times = compute_exit_times(dt, people, results) tmp = domain.door_distance.copy() tmp[I0, J0] = exit_times people_init = sp.ma.MaskedArray(sp.zeros(people.shape, dtype=int), mask=domain.mask) people_init.data[I0, J0] = 1 vmin = (tmp * (people_init == 1)).min() vmax = (tmp * (people_init == 1)).max() cmap = cm.Greys ax1.imshow(tmp * (people_init == 1), interpolation='nearest', extent=[domain.xmin, domain.xmax, domain.ymin, domain.ymax], origin='lower', alpha=1.0, cmap=cmap, norm=colors.BoundaryNorm(boundaries=sp.linspace( vmin, vmax, cmap.N + 1), ncolors=cmap.N)) mask = (results == -1) traj = sp.swapaxes(sp.ma.MaskedArray(results, dtype=int, mask=mask), 1, 2) traj = traj[:, :, [1, 0]] col = sp.array([]) for id in sp.arange(Np): ns = sp.where(results[id, 0, :] != -1)[0].shape[0] - 1 col = sp.hstack((col, sp.ones(ns) * exit_times[id])) paths = LineCollection(0.5*pixel_size+pixel_size*traj, linewidths=2, linestyle="solid", cmap=cmap, norm=colors.BoundaryNorm( \ boundaries=sp.linspace(vmin,vmax,cmap.N+1), \ ncolors=cmap.N) \ ) paths.set_array(exit_times) ax1.add_collection(paths) if (axis): ax1.set_xlim(axis[0], axis[1]) ax1.set_ylim(axis[2], axis[3]) ax1.set_xticks([]) ax1.set_yticks([]) ax1.axis('off') # ax1.set_xlabel('x',color='white') # ax1.set_ylabel('y',color='white') # ax1.set_title('t',color='white') # ax1.spines['left'].set_color('white') # ax1.spines['right'].set_color('white') # ax1.spines['bottom'].set_color('white') # ax1.spines['top'].set_color('white') #ax1.axis('off') fig.canvas.draw() if (savefig): fig.savefig(filename, dpi=150, bbox_inches='tight', pad_inches=0) plt.pause(0.01)
# -*- coding: utf-8 -*- """ Created on Sun Oct 06 12:37:36 2013 @author: Gebruiker """ from ProcessCEST.CESTimports import * from ProcessImages.ReadInput import * import math import scipy fieldmap = Bruker2AnalyzeImg('TD_GlutCEST_t02_lZ1_9_1') fieldmap.data = scipy.swapaxes( fieldmap.data, 1, 2 ) #fieldmap array is ordered differently. This puts it in the same order as e.g. the voxel size filelist = [x.replace('.img', '') for x in glob.glob('*.img') ] #cool list comprehension that gets all files cestimg = Bruker2AnalyzeImg('TD_GlutCEST_t02_lZ1_15_1') cestarray = scansToArray(filelist, start=15) cestimg.data = cestarray fieldmap.resampleImage( cestimg) #resamples fieldmap to match CEST image resolution fieldmap.data = fillEdges(fieldmap, cestimg) fieldmapslice = getCorrespondingSlice(fieldmap, cestimg) offsimg1, pseudofieldmap1, indexerrors1 = correctB0(cestimg.data, ranges,
def apply_chords(im, spacing=1, axis=0, trim_edges=True, label=False): r""" Adds chords to the void space in the specified direction. The chords are separated by 1 voxel plus the provided spacing. Parameters ---------- im : ND-array An image of the porous material with void marked as ``True``. spacing : int Separation between chords. The default is 1 voxel. This can be decreased to 0, meaning that the chords all touch each other, which automatically sets to the ``label`` argument to ``True``. axis : int (default = 0) The axis along which the chords are drawn. trim_edges : bool (default = ``True``) Whether or not to remove chords that touch the edges of the image. These chords are artifically shortened, so skew the chord length distribution. label : bool (default is ``False``) If ``True`` the chords in the returned image are each given a unique label, such that all voxels lying on the same chord have the same value. This is automatically set to ``True`` if spacing is 0, but is ``False`` otherwise. Returns ------- image : ND-array A copy of ``im`` with non-zero values indicating the chords. See Also -------- apply_chords_3D """ if spacing < 0: raise Exception('Spacing cannot be less than 0') if spacing == 0: label = True result = sp.zeros(im.shape, dtype=int) # Will receive chords at end slxyz = [slice(None, None, spacing * (axis != i) + 1) for i in [0, 1, 2]] slices = tuple(slxyz[:im.ndim]) s = [[0, 1, 0], [0, 1, 0], [0, 1, 0]] # Straight-line structuring element if im.ndim == 3: # Make structuring element 3D if necessary s = sp.pad(sp.atleast_3d(s), pad_width=((0, 0), (0, 0), (1, 1)), mode='constant', constant_values=0) im = im[slices] s = sp.swapaxes(s, 0, axis) chords = spim.label(im, structure=s)[0] if trim_edges: # Label on border chords will be set to 0 chords = clear_border(chords) result[slices] = chords # Place chords into empty image created at top if label is False: # Remove label if not requested result = result > 0 return result
import lmdb import argparse import sys sys.path.insert(0, "/home/ogaki/Workspace/caffe/python") import caffe import cv2 import scipy parser = argparse.ArgumentParser() parser.add_argument("db") parser.add_argument("kvfile") parser.add_argument("imgdir") args = parser.parse_args() db = lmdb.open(path=args.db, map_size=1024*1024*1024) db.open_db() with db.begin(write=True) as buf: for i, line in enumerate(open(args.kvfile)): if i % 10000 == 0: print >> sys.stderr, i key = line.split()[0] imgfilepath = line.split()[1] #img = cv2.imread(args.imgdir+"/"+imgfilepath).transpose([2,0,1]) img = caffe.io.load_image(args.imgdir+"/"+imgfilepath).astype(float) img = scipy.swapaxes(img, 0, 2) datum = caffe.io.array_to_datum(img) buf.put(key, datum.SerializeToString())
def window(x, windowname = 'hanning', normalize = False): """returns w Create a window of length :math:`x`, or a hanning window sized to match :math:`x` such that x*w is the windowed result. Parameters x: 1) Integer. Number of points in desired hanning windows. 2) Array to which window needs to be applied. windowname: One of: hanning, hamming, blackman, flatwin, boxwin normalize (False): Adjust power level (for use in ASD) to 1 Returns w: 1) hanning window array of size x 2) windowing array. Windowed array is then x*w :Example: >>> import numpy as np >>> import vibrationtesting as vt >>> import matplotlib.pyplot as plt >>> sample_freq = 1e3 >>> tfinal = 5 >>> fs = 100 >>> A = 10 >>> freq = 5 >>> noise_power = 0.001 * sample_freq / 2 >>> time = np.reshape(np.arange(0, tfinal, 1/sample_freq),(1,-1)) >>> xsin = A*np.sin(2*np.pi*freq*time) >>> xcos = A*np.cos(2*np.pi*freq*time) # assembling individual records. vstack assembles channels >>> x=np.dstack((xsin,xcos)) # assembling individual records. vstack >>> xw=vt.hanning(x)*x >>> plt.subplot(2, 1, 1) <matplotlib.axes._subplots.AxesSubplot object at ...> >>> plt.plot(time.T,x.T) [<matplotlib.lines.Line2D object at ...>] >>> plt.ylim([-20, 20]) (-20, 20) >>> plt.title('Unwindowed data, 2 records.') <matplotlib.text.Text object at ...> >>> plt.ylabel('$x(t)$') <matplotlib.text.Text object at ...> >>> plt.subplot(2, 1, 2) <matplotlib.axes._subplots.AxesSubplot object at ...> >>> plt.title('Original (raw) data.') <matplotlib.text.Text object at ...> >>> plt.plot(time[0,:],xw[0,:],time[0,:],vt.hanning(x)[0,:]*A,'--',time[0,:],-vt.hanning(x)[0,:]*A,'--') [<matplotlib.lines.Line2D object at ...>] >>> plt.ylabel('Hanning windowed $x(t)$') <matplotlib.text.Text object at ...> >>> plt.xlabel('time') <matplotlib.text.Text object at ...> >>> plt.title('Effect of window. Note the scaling to conserve ASD amplitude') <matplotlib.text.Text object at ...> >>> plt.show() """ if isinstance(x,(list, tuple, np.ndarray)): # Create Hanning windowing array of dimension n by N by nr # where N is number of data points and n is the number of number of inputs or outputs. # and nr is the number of records. swap = 0 if len(x.shape) == 1: # We have either a scalar or 1D array if x.shape[0] == 1: print(" x is a scalar... and shouldn\'t have entered this part of the loop.") else: N = len(x) f = self.window(N , windowname = windowname) elif len(x.shape)==3: if x.shape[0]>x.shape[1]: x = sp.swapaxes(x,0,1) swap = 1 print('Swapping axes temporarily to be compliant with expectations. I\'ll fix them in your result') f=window(N , windowname = windowname) f,_, _=np.meshgrid(f, np.arange(x.shape[0]),np.arange(x.shape[2])) if swap == 1: f = sp.swapaxes(f,0,1) elif len(x.shape)==2: #f,_=np.meshgrid(f[0,:],np.arange(x.shape[0])) #print('b') if x.shape[0]>x.shape[1]: x = sp.swapaxes(x,0,1) swap = 1 print('Swapping axes temporarily to be compliant with expectations. I\'ll fix them in your result') f = window(x.shape[1] , windowname = windowname) f, _ = np.meshgrid(f, np.arange(x.shape[0])) if swap == 1: f = sp.swapaxes(f,0,1) else: #print(x) # Create hanning window of length x N = x #print(N) if windowname is 'hanning': f = np.sin(np.pi * np.arange(N)/(N-1))**2 * np.sqrt(8/3) elif windowname is 'hamming': f=(0.54-0.46*np.cos(2*np.pi*(np.arange(N))/(N-1)))*np.sqrt(5000/1987) elif windowname is 'blackman': print('blackman') f=(0.42-0.5*np.cos(2*np.pi*(np.arange(N)+.5)/(N))+.08*np.cos(4*np.pi*(np.arange(N)+.5)/(N)))*np.sqrt(5000/1523) elif windowname is 'flatwin': f=1.0-1.933*np.cos(2*np.pi*(np.arange(N))/(N-1))+1.286*np.cos(4*np.pi*(np.arange(N))/(N-1))-0.338*np.cos(6*np.pi*(np.arange(N))/(N-1))+0.032*np.cos(8*np.pi*(np.arange(N))/(N-1)) elif windowname is 'boxwin': f=np.ones((1,N)) else: f = np.ones((1,N)) print("I don't recognize that window name. Sorry") if normalize is True: f = f/np.linalg.norm(f) * np.sqrt(N) return f