def Sdata_gen(cineFile, index): """ Parameters ---------- cineFile : string name of a cine file index : intege index is associated to a specific cine file Returns S : Sdata class object ------- """ failure = None # print(cineFile) base = browse.get_string(os.path.basename(cineFile), '', end='.cine') # find the file where exp. parameters are given fileDir = os.path.dirname(cineFile) + '/' fileList, n = browse.get_fileList(fileDir, 'txt', root='Setup_file_Reference_', display=True, sort='date') file_param = os.path.dirname(cineFile) + '/' + 'Setup_file_Ref.txt' print '----Setup txt file(s)---' print fileList print '------------------------' for f in fileList: s = browse.get_string(f, 'Setup_file_Reference_', end='.txt') # print(base) # print('extract :'+s) if browse.contain(base, s): file_param = f print 'file_param: ' + file_param # input() # file = os.path.dirname(cineFile)+'/References/Ref_'+base+'.txt' # file = os.path.dirname(cineFile)+'/'+'Setup_file_Ref.txt' #/Volumes/labshared/Stephane_lab1/25015_09_22/References/Ref_PIV_sv_vp_zoom_Polymer_200ppm_X25mm_fps5000_n18000_beta500mu_H1180mm_S300mm.txt' # print(file) # try: print '----Cine file being processed:----' print cineFile print '----------------------------' S = Sdata(fileCine=cineFile, index=index, fileParam=file_param) print '----------------------------' print 'Sdata class object S is created!' print 'Attributes of S are...' print dir(S) print 'Attributes of S.param are...' print dir(S.param) print '----------------------------' S.write() return S
def find_dataType(S): s = browse.get_string(S.fileCine, '/PIV', '.cine') if not s == '': return '2D_PIVmovie' s = browse.get_string(S.fileCine, 'Bubbles', '.cine') if not s == '': return '2D_bubbles' return 'Unknown'
def get_fileList(self, display=False): """ Return the list of PIV data (.txt files) associated to this measure """ fileList, n = browse.get_fileList(self.dataDir + '/', self.frmt, display=display, sort='name') if n == 0: print("NO PIV files found locally at : " + self.dataDir) print("Look for other possible locations") rootDir = file_architecture.get_dir(self.Id.date) dataDir = browse.get_string(self.dataDir, self.Id.date, from_end=True) dataDir = rootDir + dataDir fileList, n = browse.get_fileList(dataDir + '/', self.frmt, display=display, sort='name') if n == 0: print("No PIV files found globally !") else: print("PIV files found at : " + rootDir) # print(n) return fileList, n
def load_Mdata_serie(date, index=[], mindex=[], data=True): # list with the different Sdata files Mlist = [] fileList = getloc(date, index, mindex) for file in fileList: index = int(browse.get_string(file, 'M_' + date + '_', '_')) try: M = load_Mdata_file(file, data=data) done = True except: # retrieve the Sdata associated to it S = Sdata_manip.load_Sdata(date, index) if S is not None: Measure_gen_serie(S) M = load_Mdata_file(file, data) done = True else: done = False # for i,M in enumerate(Mlist): # M_gen(S,dataDir,mindex,typ='Mdata') if done: Mlist.append(M) else: print("") print("unable to read Sdata for " + date) print("") return Mlist
def draw_grid(M, ax, x0, y0, Mesh=50, Bar=10, H=10, N=5, facecolor='y', edgecolor='k', linewidth=2): """ Draw the grid at the specified position. """ file = M.Sdata.fileCine ind = browse.get_string(os.path.basename(file), '_M', end='mm') if M.Id.date == '2016_03_05': ind = 24 if not ind == '': Bar = 4 H = 8 Mesh = int(ind) # print(int(ind)) N = 9 else: Mesh = 50 positions = [(i * Mesh + x0, y0) for i in range(-(N // 2), N // 2 + 1)] width = Bar height = H # grid = [] for p in positions: square = patches.Rectangle(centered(p, width, height), width, height, facecolor=facecolor, edgecolor=edgecolor, linewidth=linewidth) ax.add_patch(square)
def make_ref_file(cinefile, folder=''): keys = ['fx', 'im0', 'x0', 'y0', 'angle'] List_info = [[0] for i in range(len(keys))] if folder == '': folder = os.path.dirname(cinefile) #generate an empty ref file associated to each cine file #Should be manually filled out from images measurements cinebase = browse.get_string(os.path.basename(cinefile), '', '.cine') name = folder + 'Ref_' + cinebase + '.txt' if not os.path.isfile(name): print(name) #check first if a Ref file exists already # Ref_PIV_sv_vp_zoom_Polymer_200ppm_X25mm_fps5000_n18000_beta500mu_H1180mm_S300mm rw_data.write_dictionnary(name, keys, List_info) else: print('Reference file exists already') pass #directory = '/Volumes/labshared3/Stephane/Experiments/Accelerated_grid/2015_03_24/' #gen(directory)
def make_movie(cinefile, nimage, start=0, stop=1, step=1, folder='', framerate=30, quality=50): #generate a folder with tiff images : it would be easier if a avi file is generated directly root = os.path.basename(cinefile) base = browse.get_string(root, '', end='.cine') if folder == '': folder = os.path.dirname(cinefile) folder = '/References' print(folder + base) cine2pic.cine2tiff(cinefile, mode='Sample', step=step, ctime=2, start=start, stop=nimage * step + start, folder=folder, post=base)
def saveDir(file, post=''): fileroot = browse.get_string(file, '', '.cine', 0) if not (fileroot == ''): Dir = fileroot + post + '/' root = 'im' if not os.path.isdir(Dir): os.makedirs(Dir) else: print('not a cine file') return Dir, root
def make_timestep_files(fileList,Dt=args.imstep,starts=[],ends=[],Dt_list=[]): """ Generate a timestep .txt file that will be used to process the data with the right time step INPUT ----- fileList : list of filename to process Dt : int. Separation between image A and image B Optional variables (not implemented yet) : starts, ends and Dt_list to set a list of timestep for different instants in the movie. OUTPUT ----- NONE """ keys = ['start','end','Dt'] for file in fileList[args.start:args.end]: n = str(browse.get_string(file,start = '_n',end='_')) try: int(n) except: n='' if n=='': #get the number of images from the cinefile try: c = cine.Cine(file) except: print('Cine file temporary unavailable') return None c=cine.Cine(file) n=c.len()-1 #print(n) values = [[0],[n],[Dt]] base = browse.get_string(os.path.basename(file),'','.cine') file_timestep = os.path.dirname(file) +'/PIV_timestep_'+base+'.txt' if not os.path.isfile(file_timestep): rw_data.write_dictionnary(file_timestep, keys, values)
def get_parameters_isotropic( file): ##use this method to get parameters for the isotropic data """ Parameters ---------- file Returns ------- """ List_key = ['zl', 'yl', 'xl', 't0', 'tl', 'y0', 'x0', 'z0'] param = {} for k in List_key[:-1]: param[k] = int( browse.get_string(file, '_' + k + '_', end='_', display=False)) k = List_key[-1] param[k] = int( browse.get_string(file, '_' + k + '_', end='/', display=False)) return param
def get_data(fileList): dataList = [] for name in fileList: W = browse.get_number(name, '_W', 'pix_') Dt = int(browse.get_string(name, 'pix_Dt_', '_')) Header, Data = rw_data.read_dataFile(name, ',', ',') # indexA=browse.get_number(Header[1],'A: im','.tiff') #name of the image is localized on the second line of the ASCII file # indexB=browse.get_number(Header[1],'B: im','.tiff') Data = pivlab.switch_keys(Data) dataList.append(Data) for key in ['u', 'v']: Data[key] = (cdata.rm_nans([np.asarray(Data[key])], d=1, rate=0.05))[0] return dataList
def get_parameters(file): """ If the hdf5 file is named like "isotropic1024_zl_20_yl_20_xl_20_coarse_t0_0_tl_1_y0_0_x0_0_z0_0_", this method gets each parameter values. Parameters ---------- file: str a definite path to the hdf5 file Returns ------- param: dict parameter names and values read from the name of the hdf5 file """ List_key = ['zl', 'yl', 'xl', 't0', 'tl', 'y0', 'x0', 'z0'] param = {} for k in List_key: param[k] = int( browse.get_string(file, '_' + k + '_', end='_', display=False)) k = List_key return param
def make_result_folder(fileList,type_analysis='Sample',algo='PIVlab',W=32,ratio=None): """ Create folders for storing the PIVlab Data (now processed in matlab) INPUT ----- fileList : List of string filename List to be read type_analysis : string (default value 'Sample') Standard presaved types of analysis (Sample = 1/10 images processed, Full_single', every images, Full_double every pair of image (effective ratio = 2)) Full_single : ratio = 1 Full_double : ratio = 2 Sample : ratio = 10 algo : string (default value 'PIVlab') Name of the PIV algorithm used to processed the data W : int (default value = 32) Window size used for PIV processing. ratio : number of images / number of pair of images processed. default value = 10. Can be set to standard values using type_analysis OUTPUT ------ None 0 """ types = dict(Sample=ratio,Full_double=2,Full_single=1) if type_analysis in types.keys(): ratio = types[type_analysis] else: #use the value given in argument for ratio pass for file in fileList[args.start:args.end]: Dir = os.path.dirname(file) rootDir = Dir +'/PIV_data' basename = browse.get_string(os.path.basename(file),'',end='.cine') foldername = rootDir+'/'+algo+'_ratio'+str(ratio)+'_W'+str(W)+'pix_'+basename if not os.path.isdir(foldername): os.makedirs(foldername)
def title(M): date = M.Id.date typ = browse.get_string(M.dataDir, 'piston12mm_', end='_f5Hz') savedir = './Vortex_Turbulence/Vortex_propagation/' + date + '/' + typ + '/' print(savedir) return savedir
def review(): folder = '/Volumes/Stephane/Vortex_Turbulence/' folders = glob.glob(folder + '*') l_vortices = [] D = {} D['v'] = [] D['fx'] = [] D['fps'] = [] D['date'] = [] D['index'] = [] # D['Sdata_file']=[] D['cinefile'] = [] for f in folders: # print(f) l = glob.glob(f + '/PIV*A0mm*.cine') l_vortices = l_vortices + l # print(l_vortices) for cinefile in l_vortices: s = browse.get_string(cinefile, '', '/PIV') date = s[-10:] filename = os.path.dirname(file_architecture.os_i( cinefile)) + '/Sdata_' + date + '/Cine_index_' + date + '.txt' if os.path.exists(filename): Header, data = rw_data.read_dataFile(filename, Hdelimiter='\t', Ddelimiter='\t') # print(data) # print(data) # print("l : "+l) # print(data['Names']) # print(file_architecture.os_i(cinefile)) index = \ np.where([file_architecture.os_i(cinefile) == file_architecture.os_i(name) for name in data['Names']])[0][0] index = int(data['Index'][index]) v = browse.get_number(cinefile, '_v', 'mms') if v == -1: v = browse.get_number(cinefile, 'mm_v', 'mm') fps = browse.get_number(cinefile, '_fps', '_') S = Sdata_manip.load_Sdata(date, index) fx = S.param.fx D['date'].append(date) D['index'].append(index) D['v'].append(v) D['fps'].append(fps) D['fx'].append(fx) # D['Sdata_file'].append(filename) D['cinefile'].append(cinefile) print(D['v']) filename = './Vortices/free_index_no_cine.txt' rw_data.write_a_dict(filename, D, delimiter='\t')
def set_date(self, file): # Date # file=self.Sdata.fileCine self.date = browse.get_string(file, "/20", "/", -2)
def load_exp_parameters(self, fileParam=''): """ Read experimental parameters from a setup file, or let user manually type them on the screen. The parameters are stored in a param class object, and this param class object is attributed to a Sdata class object. Parameters ---------- opt : str, default: "w" option. If opt=="r", the filename becomes /path/to/.../CineFile_param . (Extension is not included) Otherwise, the filename becomes /path/to/../CineFileDir/PIV_date_index_mindex_param Returns name : str "/.../CineFileDir/CineFile_param" or "/.../CineFileDir/PIV_date_index_mindex_param" ------- """ self.fileParam = self.fileParam + '.txt' self.im_ref = self.read_reference( ref=0 ) #self.read_reference(ref=0) outputs spatial resolution of cine images. e.g.- (640, 1024) Note that this method uses the cine Class. # default value of fileParam : if True: # fileParam == '': base = browse.get_string(os.path.basename(self.Sdata.fileCine), '', end='.cine') # print(base) fileRef = os.path.dirname( self.Sdata.fileCine) + '/Setup_file_Reference*.txt' # print(fileRef) fileList = glob.glob( fileRef) # make a list of Setup_file_Reference*.txt files. #print(base) #print(fileList) for filename in fileList: pattern = browse.get_string(filename, 'Setup_file_Reference', end='.txt') if pattern in base: # if there is such a txt file with a filename which contains 'Setup_file_Reference', the file must be the one that cotains experimental parameters. fileParam = filename # other name : print 'Experimental parameters may be stored here:' print fileParam print 'Does this file exist?' if os.path.isfile(fileParam): print '... Yes! Read experimental parameters from this file.' #Read the parameters from the param file Header, Data = rw_data.read_dataFile(fileParam, Hdelimiter='\t', Ddelimiter='\t') # print Header print Data #Add the Data keys to attributes for i in Data.keys(): setattr(self, i, Data[i][0]) print 'Now, this param class object has new attributes which are named as same as the header of ' + fileParam else: print '... No. You specified to read ' + self.fileParam + ' if this is just ".txt", you did not specify the setup file. ' print 'Does this file actually exist?' ######## If the argument "fileParam" is given,... read that file as a setup file. if os.path.isfile(self.fileParam): self.im_ref = self.read_reference( ref=0 ) #Read spatial resolution of cine images directory (i.e.- Open the target cine file, and grab the spatial resolution information) self.Sdata.read_param( ) # load parameters from the parameter file ####### ####### If the algorithm above could not find the setuo file, manually input the experimental parameters. else: print '... No. ' print 'We could not find the setup file. Please type experimental parameters now.' self.im_ref = self.read_reference( ref=0 ) #Read spatial resolution of cine images directory (i.e.- Open the target cine file, and grab the spatial resolution information) self.manual_input()
def compile(Mlist, V=None, method='circulation'): symbol = {'50': '^', '125': 'o', '250': 's'} color = {'circulation': 'r', 'vorticity': 'b', 'joseph': 'k'} labels = {key: color[method] + symbol[key] for key in symbol.keys()} if V == None: sub_labels = labels piston_v = None else: piston_v = str(V) sub_labels = {piston_v: labels[piston_v]} # ,'125':'ro','250':'bs'} figs = {} for i, M in enumerate(Mlist): piston1 = browse.get_string(M.Sdata.fileCine, '_v', end='.cine', shift=0, display=False, from_end=True) piston2 = browse.get_string(M.Sdata.fileCine, '_v', end='_p30mum', shift=0, display=False, from_end=True) error = 0.25 for piston in [piston1, piston2]: if piston in sub_labels.keys(): print(M.dataDir) dx = np.mean(np.diff(M.x[0, :])) print('Spatial scale : ' + str(dx) + ' mm/box') lc, std_lc, Gamma, std_Gamma = compute(M, method=method, display=False, fignum=(i + 1) * 2) # print(piston,dx,lc,std_lc) if std_lc / lc < error: graphes.errorbar(dx, lc, [0], std_lc, label=labels[piston], fignum=250) figs.update(graphes.legende('mm/box', 'Core size (mm)', '')) graphes.set_axis(0, 1.5, 0, 6.) if method == 'circulation': # if np.abs(std_Gamma/Gamma)<error: graphes.errorbar(dx, Gamma, [0], std_Gamma, label=labels[piston], fignum=251) figs.update( graphes.legende('mm/box', 'Circulation (mm^2/s)', '')) graphes.set_axis(0, 1.5, -2 * 10**4, 0) # print(piston,dx,lc,std_lc print('') print('figure', figs) print(figs) graphes.save_figs(figs, suffix='Compilation_method_' + method + '_v' + piston_v)