def PlotData(directory, filname): specdata = spc.File(directory + 'spcFiles/' + filname + '.spc') Plot = specdata.plot(filname) Plot.savefig(directory + "pngFiles/" + filname + '.png') print 'specdata:', type(specdata)
def convert(self): self.fol_val = str(self.folder.get()) self.fmt_val = str(self.output_fmt.get()) print("About to convert {} with {} ext".format(self.fol_val, self.fmt_val)) if self.fmt_val == 'txt': exten = '.txt' delim = '\t' else: # defaults exten = '.csv' delim = ',' flist = [] # only directory here ffn = os.path.abspath(self.fol_val) for f in os.listdir(ffn): flist.append(os.path.join(ffn, f)) # process files for fpath in flist: if fpath.lower().endswith('spc'): foutp = fpath[:-4] + exten try: print(fpath, end=' ') f = spc.File(fpath) f.write_file(foutp, delimiter=delim) print('Converted') except: print('Error processing %s' % fpath) else: print('%s not spc file, skipping' % fpath)
def _read_file(self): """ Reads a raw SPC file, updates the self.spectra attribute to have the raw y values for each index in the spectra file """ f = spc.File(self.spc_file) self.spectra = f.sub[0].y self.x_values = f.x
def readSpcFtirData(spcFile): instrumentData = spc.File(spcFile) # Take slice b/c data has trailing tab dataTable = [r.split("\t")[0:2] for r in instrumentData.data_txt().split("\n") if r != ''] # First line is headers, so we drop it dataTable = dataTable[1:] return dataTable
def open_spc_spcl(file_path): # spcファイルの場合 if file_path.endswith(".spc"): spc_file = spc.File(file_path) # spclファイル(自作漬物ファイル)の場合 elif file_path.endswith(".spcl"): with open(file_path, 'rb') as f: spc_file = pickle.load(f) return spc_file
def loadData(folder, fileName): if fileName.endswith(".spc") or fileName.endswith('.SPC'): f = spc.File(folder + '\\' + fileName) ev = f.x counts = f.sub[0].y elif fileName.endswith(".CSV") or fileName.endswith(".csv") or fileName.endswith(".PRN") or fileName.endswith(".prn"): ev, counts = np.genfromtxt(folder + '\\' + fileName, skip_footer=1, unpack=True, usecols =(0,1)) #load data from text file else: raise FileTypeError(fileName) return ev, counts
def read(self): try: import spc except ImportError: raise RuntimeError("To load spc files install spc python module (https://github.com/rohanisaac/spc)") spc_file = spc.File(self.filename) if spc_file.talabs: table = self.multi_x_reader(spc_file) else: table = self.single_x_reader(spc_file) return table
def _readSPC(path, spectra, **kwargs): # Cancelout output of this module _stdout = _copy.copy(sys.stdout) sys.stdout = None spc_file = spc.File(path, **kwargs) # Restart standard output sys.stdout = _stdout wvnmbrs = spc_file.x # Append the new spectrum/spectra for signal in spc_file.sub: spectra.addSpectrum(wvnmbrs, signal.y)
def asdLoadPortableSampleData(portableDataFile, dataProduct): # clear out any old data samples = AsdSample.objects.filter(dataProduct=dataProduct) samples.all().delete() if portableDataFile: instrumentData = spc.File(portableDataFile) # Take slice b/c data has trailing tab dataTable = [r.split("\t")[0:2] for r in instrumentData.data_txt().split("\n") if r != ''] for wl, ab in dataTable[1:]: # Slice starting @ 1 because 1 line is header sample = AsdSample( dataProduct = dataProduct, wavelength = wl, absorbance = ab) sample.save()
def convert(self): self.fol_val = str(self.folder.get()) outfol_val = str(self.outputdir.get()) if not outfol_val.endswith("/"): outfol_val = outfol_val + "/" #self.fmt_val = str(self.output_fmt.get()) #print("About to convert {} with {} ext".format(self.fol_val, self.fmt_val)) exten = '.csv' delim = ',' flist = [] # only directory here ffn = os.path.abspath(self.fol_val) #ffn is the input folder name #print(ffn) #sys.exit(0) onlyfilename = [] ffn = ffn + "/" for f in os.listdir(ffn): flist.append(os.path.join(ffn, f)) onlyfilename.append(f) # process files ind = 0 for ind in range(0, len(flist)): fpath = flist[ind] fname = onlyfilename[ind] if fpath.lower().endswith('spc'): foutp = fpath[:-4] + exten #foutp=outfol_val+fname[:-4]+exten try: #print(fpath, end=' ') f = spc.File(fpath) f.write_file(foutp, delimiter=delim) #print('Converted') except: print('Error processing %s' % fpath) print(fpath) print(foutp) sys.exit(0) #else: # print('%s not spc file, skipping' % fpath) sampleinfo = {} testind = 1 for f in onlyfilename: sampleinfo[f.replace(".spc", ".csv")] = "test" + str(testind) testind = testind + 1 print(sampleinfo) self.csvtoldamatrix(ffn, sampleinfo, outfol_val)
def main(): desc = 'Converts *.spc binary files to text using the spc module' parser = GooeyParser(description=desc) parser.add_argument('filefolder', widget='DirChooser', help='Input directory containing spc file') fformat = parser.add_mutually_exclusive_group() fformat.add_argument('-c', '--csv', help='Comma separated output file (.csv) [default]', action='store_true') fformat.add_argument('-t', '--txt', help='Tab separated output file (.txt)', action='store_true') args = parser.parse_args() if args.txt: exten = '.txt' delim = '\t' else: # defaults exten = '.csv' delim = ',' flist = [] # only directory here ffn = os.path.abspath(args.filefolder) for f in os.listdir(ffn): flist.append(os.path.join(ffn, f)) # process files for fpath in flist: if fpath.lower().endswith('spc'): foutp = fpath[:-4] + exten try: print(fpath, end=' ') f = spc.File(fpath) f.write_file(foutp, delimiter=delim) print('Converted') except: print('Error processing %s' % fpath) else: print('%s not spc file, skipping' % fpath)
def read_spectra(spectral_file, start_x=600, end_x=1450): """ Uses spc module from https://github.com/rohanisaac/spc (which appears to be abandonware, but has yet to fail on me) to read in a spectral file, then takes its first derivative and normalizes its data. :param spectral_file: A .spc file produced by our super duper FTIR machine. :param start_x: Start of interval over which we want to look at data :param end_x: End of interval over which we want to look at data :return: Normalized first derivative over the interval specified. """ assert end_x > start_x spectral_data = spc.File(spectral_file) y = list() # Iterate through file, taking first derivative over our range of important stuff. for i in range(len(spectral_data.x) - 2, 0, -1): x_value = spectral_data.x[i] if start_x < x_value < end_x: difference = spectral_data.sub[0].y[i] - spectral_data.sub[0].y[i + 1] y.append(difference) # Note: it's possible to get a value of zero for norm if the array has all 0 values - this seems really (x1000000) # unlikely to ever happen with a spectra, so we won't bother catching an error here. norm = np.linalg.norm(y) return y / norm
def fill_df(): global df_init global file_list count = 0 #scan is each file name as a str #loop through each file in the selected directory for scan in os.listdir(): fileName = scan if fileName[-3:] == 'spc': file_list.append(fileName) count += 1 f = spc.File( fileName ) #Initialize spectra object f. Use f to call the x and y components. wave_list = f.x #list of all the wavelengths df_init['wavelength' + str( count )] = wave_list #casting the wavelength list into the dataframe percentR = f.sub[0].y #list of all the R% values df_init[ fileName] = percentR #casting the R% list into the dataframe else: pass return count
import spc #https://github.com/rohanisaac/spc import os def findFiles(path, extension): files = [] for i in os.listdir(path): if i.endswith(extension): files.append(path + str(i)) files.sort() return files path = './' files = findFiles(path, ".spc") for i in files: filename = i.split('/')[-1][:-4] f = spc.File(i) f.write_file(filename + '.csv')
def extractRamanSpc(path, bg_path=False, combine_statics=False): '''Takes all .spc files from a directory and creates Raman_Spectrum object for each and also background subtracts, if specified .spc files must be directly exported at time of measurement. If .wdf file was re-opened with WiRE and then saved as .spc, use old code ('2017-04-14_Spectra_Class') Plots ASCII table with relevant metadata. Set table=False to omit this Also plots table for background files if user specifies bg_table = True''' '''Actual power values for each % laser power in μW. Measured on 09/05/2017.''' print '\nGathering .spc (meta)data...\n' p532 = { 0.0001: 0.01, 0.05: 4.75, 0.1: 12.08, 0.5: 49.6, 1.0: 88.1, 5.0: 666, 10.0: 1219, 50.0: 5360, 100.0: 9650 } p633 = { 0.0001: 0.01, 0.05: 1, 0.1: 2, 0.5: 10, 1.0: 20, 5.0: 112, 10.0: 226, 50.0: 1130, 100.0: 2200 } p785 = { 0.0001: 0.17, 0.05: 8.8, 0.1: 19.1, 0.5: 47.8, 1.0: 104, 5.0: 243, 10.0: 537, 50.0: 1210, 100.0: 2130 } powerConverter = { 532: p532, 633: p633, 785: p785 } #Assigns each laser power dictionary to the appropriate wavelength. os.chdir(path) spcFiles = [f for f in os.listdir('.') if f.endswith('.spc')] spectra = [] for n, spcFile in enumerate(spcFiles): filename = spcFile[:-4] #Removes extension from filename string f = spc.File(spcFile) #Create File object from .spc file laserWl = int( f.log_dict['Laser'][7:10] ) #Grabs appropriate part of laser wavelength entry from log and converts to integer (must be 3 characters long) lpKeys = ['Laser_power', ' Laser_power'] for lpKey in lpKeys: if lpKey in f.log_dict.keys(): break try: laserPower = float( f.log_dict[lpKey][13:-1] ) #Grabs numeric part of string containing laser power info and converts to float except: laserPower = 'Undefined' if laserPower in [0.0001, 0.05, 0.1, 0.5, 1.0, 5.0, 10.0, 50.0, 100.0]: absLaserPower = float( powerConverter[laserWl][laserPower] ) / 1000 #Returns absolute laser power (in mW), given laser wavelength and % laser power. else: absLaserPower = 'Undefined' #To avoid errors if laser power is not recorded correctly try: integrationTime = float(f.log_dict['Exposure_time'][6:]) except: integrationTime = float(f.log_dict[' Exposure_time'][6:]) wavenumbers = f.x #Pulls x data from spc file nScans = int( f.__dict__['fnsub'] ) #Number of Raman spectra contained within the spc file (>1 if file contains a kinetic scan) ramanIntensities = [f.sub[i].y for i in range(nScans) ] #Builds list of y data arrays metadata = f.__dict__ #Pulls metadata dictionary from spc file for easy access if absLaserPower != 'Undefined': absRamanIntensities = [ (spectrum * 1000) / (absLaserPower * integrationTime) for spectrum in ramanIntensities ] else: absRamanIntensities = ['N/A'] * nScans if nScans == 1: ramanIntensities = ramanIntensities[ 0] #Reduces to single array if not a kinetic scan absRamanIntensities = absRamanIntensities[0] #Also for this spectra.append( Raman_Spectrum(filename, metadata, laserWl, laserPower, absLaserPower, integrationTime, nScans, wavenumbers, ramanIntensities, absRamanIntensities)) return spectra
def DataExtrating(directory, filname): specdata = spc.File(directory + 'spcFiles/' + filname + '.spc') specdata.data_txt() specdata.write_file(directory + 'txtFiles/' + filname + '.txt') return specdata.data_txt()
def extractRamanSpc(path, bg_path=False, combine_statics=False, xaxis='wn'): '''Takes all .spc files from a directory and creates Raman_Spectrum object for each and also background subtracts, if specified .spc files must be directly exported at time of measurement. If .wdf file was re-opened with WiRE and then saved as .spc, use old code ('2017-04-14_Spectra_Class') Plots ASCII table with relevant metadata. Set table=False to omit this Also plots table for background files if user specifies bg_table = True''' '''Actual power values for each % laser power in μW. Measured on 09/05/2017.''' print('\nGathering .spc (meta)data...\n') p532 = { 0.0001: 0.01, 0.05: 4.75, 0.1: 12.08, 0.5: 49.6, 1.0: 88.1, 5.0: 666., 10.0: 1219., 50.0: 5360., 100.0: 9650. } p633 = { 0.0001: 0.01, 0.05: 1., 0.1: 2., 0.5: 10., 1.0: 20., 5.0: 112., 10.0: 226., 50.0: 1130., 100.0: 2200. } p785 = { 0.0001: 0.17, 0.05: 8.8, 0.1: 19.1, 0.5: 47.8, 1.0: 104., 5.0: 243., 10.0: 537., 50.0: 1210., 100.0: 2130. } powerConverter = { 532: p532, 633: p633, 785: p785 } #Assigns each laser power dictionary to the appropriate wavelength. os.chdir(path) spcFiles_full = sorted(os.listdir('.'), key=os.path.getmtime) # spcFiles_full = sorted(os.listdir('.'), key=os.path.getctime) print(spcFiles_full) spcFiles = [f for f in spcFiles_full if f.endswith('.spc')] creation_times = [time.ctime(os.path.getmtime(f)) for f in spcFiles] # creation_times = [time.ctime(os.path.getctime(f)) for f in spcFiles] spectra = [] for n, spcFile in enumerate(spcFiles): #try: filename = spcFile[:-4] #Removes extension from filename string f = spc.File(spcFile) #Create File object from .spc file # laserWlKeys = ['Laser', ' Laser'] laserWlKeys = [b'Laser', b' Laser'] for laserWlKey in laserWlKeys: if laserWlKey in list(f.log_dict.keys()): break laserWl = int( f.log_dict[laserWlKey][7:10] ) #Grabs appropriate part of laser wavelength entry from log and converts to integer (must be 3 characters long) lpKeys = [b'Laser_power', b' Laser_power'] for lpKey in lpKeys: if lpKey in list(f.log_dict.keys()): break try: laserPower = float( f.log_dict[lpKey][13:-1] ) #Grabs numeric part of string containing laser power info and converts to float except: laserPower = 'Undefined' if laserPower in [0.0001, 0.05, 0.1, 0.5, 1.0, 5.0, 10.0, 50.0, 100.0]: absLaserPower = float( powerConverter[laserWl][laserPower] ) / 1000 #Returns absolute laser power (in mW), given laser wavelength and % laser power. else: # absLaserPower = 'Undefined' #To avoid errors if laser power is not recorded correctly absLaserPower = 0 try: integrationTime = float(f.log_dict[b'Exposure_time'][6:]) except: integrationTime = float(f.log_dict[b' Exposure_time'][6:]) accumulations = int(f.log_dict[b'Accumulations'][15:]) if xaxis == 'wn': wavenumbers = f.x #Pulls x data from spc file elif xaxis == 'wl': wavenumbers = 1e7 * (1 / laserWl - 1 / f.x) nScans = int( f.__dict__['fnsub'] ) #Number of Raman spectra contained within the spc file (>1 if file contains a kinetic scan) ramanIntensities = np.array([f.sub[i].y for i in range(nScans) ]) #Builds list of y data arrays grating = float(f.log_dict[b'Grating_grooves'][9:13]) metadata = f.__dict__ #Pulls metadata dictionary from spc file for easy access if absLaserPower != 'Undefined': absRamanIntensities = [ old_div( (spectrum * 1000), (absLaserPower * integrationTime * float(accumulations))) for spectrum in ramanIntensities ] else: absRamanIntensities = ['N/A'] * nScans if nScans == 1: ramanIntensities = ramanIntensities[ 0] #Reduces to single array if not a kinetic scan absRamanIntensities = absRamanIntensities[0] #Also for this creation_time = creation_times[n] spectra.append( Raman_Spectrum(creation_time, filename, metadata, laserWl, laserPower, absLaserPower, grating, integrationTime, accumulations, nScans, wavenumbers, ramanIntensities, absRamanIntensities)) #except Exception as e: # print 'Something went wrong with %s:' % filename # print e # continue return spectra
def _open(self): import spc # Open the reader self._fp = self.request.get_local_filename() self._data = self._spc_to_numpy(spc.File(self._fp)) self._length = len(self._data)
from __future__ import absolute_import, unicode_literals, print_function, division import os import spc tfile = 0 tpass = 0 dpath = os.path.join(os.path.dirname(__file__), 'test_data') mfile = [] rfile = [] lfile = [] for filename in os.listdir(dpath): if filename[-3:].lower() == 'spc': tfile += 1 print(filename) f1 = spc.File(os.path.join(dpath, filename)) outfile = os.path.join(dpath, 'spc2', filename + '.spc') f1.write_spc(outfile) # now, try loading and comparing f2 = spc.File(outfile) if f1.data_txt() == f2.data_txt(): print("Pass\n------") tpass += 1 else: print("Fail\n------") mfile.append(filename) print("Passed %i of %i tests. " % (tpass, tfile)) print("Did not match ref file: ", mfile)
#!/usr/bin/env python from __future__ import absolute_import, unicode_literals, print_function, division import os import spc tfile = 0 tpass = 0 dpath = os.path.join(os.path.dirname(__file__), 'test_data') mfile = [] rfile = [] lfile = [] for i in os.listdir(dpath): if i[-3:].lower() == 'spc': tfile += 1 print(i) f1 = spc.File(os.path.join(dpath, i)) outfile = os.path.join(dpath, 'txt2', i + '.txt') with open(outfile, 'r') as fin: dat = fin.read() if f1.data_txt() == dat: print("Pass\n------") tpass += 1 else: print("Fail\n------") mfile.append(i) print("Passed %i of %i tests. " % (tpass, tfile)) print("Did not match ref file: ", mfile) print("Did not have ref file: ", rfile) print("Did not load file: ", lfile)
def convert(self): #Get Folder names self.fol_val = str( self.folder.get() ) self.fol_out_val = str( self.output_folder.get() ) ffn_out = os.path.abspath(self.fol_out_val) #Get output format (txt or csv) self.fmt_val = str( self.output_fmt.get() ) #Get whether to plot or not self.fmt_plot_val = bool( self.output_plots.get() ) #Inform user of starting conversions print( "Analyzing {} with {} ext".format(self.fol_val, self.fmt_val) ) #Figure output file extension and delimiter if self.fmt_val == 'txt': exten = '.txt' delim = '\t' else: #Default is CSV exten = '.csv' delim = ',' #Initiate grain and measurement indices self.grain = 0 self.measurement = 0 #Build list for files flist = [] #Get file directory from folder value ffn = os.path.abspath( self.fol_val ) #Check for output folder location. If none, default to Input folder out_str = self.fol_out_val.replace(" ","") #If No output folder selected if out_str == "": #Default to input folder self.fol_out_val = self.fol_val self.output_folder.set( value = self.fol_out_val ) #Find how many grain files exist in folder self.grain_count = 0 for f in os.listdir( ffn ): #Check extension if f.lower().endswith('spc'): #Split file name by underscores f_split = f.split("_") #Ensure correct format for tracking if len(f_split) >= 2: #Look at second to last in split ( SomeFileName_1_1.spc ) if int( f_split[-2] ) > self.grain_count: self.grain_count = int( f_split[-2] ) #Consider grain count if self.grain_count == 0: self.output_message("Input Folder Empty", "Your input folder is either empty or the spc files are not configured correctly.", "Close", None) #Cycle through each grain count and append files for i in range(self.grain_count): #Build Measurements list mlist = [] #Append sorted files to the filelist for f in os.listdir( ffn ): #Check extension if f.lower().endswith('spc'): fl = f #Split file name to find current f_split = fl.split("_") #Ensure correct format for tracking if len(f_split) >= 2: #Check if current file is the current grain if int( f_split[-2] ) == i+1: #print( f ) #Add to measurement list mlist.append( os.path.join( ffn , f) ) #Append grain i+1 files flist.append( mlist ) ###### STOPPED HERE! FILES SORTED BY GRAIN. START ANALYZING ###### #Check if any output is selected. If not, make a silly message output_data = bool( self.output_fmt_bool.get() ) output_plot = bool( self.output_plots.get() ) if (not output_data) and (not output_plot): self.output_message( "What are you doing?", "... You have to select some output method...\n\nI mean, I could analyze this for you but you won't see it.", "Oh yeah, duh!", None ) #Else, continue analyzing else: prog_incr = 100./len( flist ) #Look at grain i #Loop through i grains for i in range( len( flist ) ): #3 tot_grain_data_list = [] #All unanalyzed grain data ave_grain_data_list = [] #Averaged data per grain sem_grain_data_list = [] #SEM data per grain #Loop through j measurements for j in range( len( flist[i] ) ): #5 #Open file into array f = spc.File( flist[i][j] ) xy_data = f.data_list() #xy data for grain i, measurement j #Append collected data to the grain_data_list for later processing tot_grain_data_list.append( xy_data ) #print( len(tot_grain_data_list) ) #total measurements #print( len(tot_grain_data_list[0]) ) #x and y #Average arrays (function? OUT = Single array) normalized_to = 1.0 ave_grain_data_list.append( self.grain_average( tot_grain_data_list, normalized_to ) ) #Find SEM in arrays (function? OUT = Single array of +/-) sem_grain_data_list.append( self.SEM_calc( tot_grain_data_list, ave_grain_data_list[0] ) ) #print( sem_grain_data_list[0][0][:5] ) #if i==0: # print( sem_grain_data_list[0][0][:10] ) #If plot, save plot data as PNG if output_plot: #Plot normalized and averaged values figsize = ( 16, 9 ) plt.figure( figsize = figsize, dpi = 600 ) plt.plot( ave_grain_data_list[0][0], ave_grain_data_list[0][1], color = '#000099', lw = 0.5 ) #Calc total SEM Values sem_above = [] sem_below = [] for k in range( len( sem_grain_data_list[0][0] ) ): sem_above.append( ave_grain_data_list[0][1][k] + sem_grain_data_list[0][1][k] ) sem_below.append( ave_grain_data_list[0][1][k] + sem_grain_data_list[0][0][k] ) #Plot +/- SEM plt.fill_between( ave_grain_data_list[0][0], sem_below, sem_above, facecolor = '#9999FF', interpolate = True ) plt.xlabel( 'cm^-1' ) plt.ylabel( 'Intensity (Normalized to {})'.format( normalized_to ) ) plt.ylim( 0., normalized_to*1.1 ) plt.xticks( np.arange( min( ave_grain_data_list[0][0] ), max( ave_grain_data_list[0][0] )+1, 500.) ) plt.yticks( np.arange( 0., normalized_to*1.1, step = 0.2*normalized_to ) ) data_line = mpatches.Patch(color='#000099', label='Averaged Data' ) sem_colors = mpatches.Patch(color='#9999FF', label='SEM Range') plt.legend(handles=[data_line, sem_colors]) plt.title( "Averaged Data in Grain {}".format( ( i+1 ) ) ) plt.grid(True) plt.savefig( os.path.join(ffn_out, "Grain {} - Averaged_RAMAN.png".format( (i+1) )) ) #If output type enabled, output data type if output_data: #Open File fle = open( os.path.join(ffn_out, "Grain {} - Averaged_RAMAN{}".format( (i+1), exten )) , 'w' ) #Create Header header = "x" + delim + "y-Ave" + delim + "y-SEM\n" fle.write( header ) #Cycle through 'x' values for SEM and for l in range( len( sem_grain_data_list[0][0] ) ): line = str( ave_grain_data_list[0][0][l] ) line += delim + str( ave_grain_data_list[0][1][l] ) line += delim + str( sem_grain_data_list[0][1][l] ) line += "\n" fle.write( line ) #Close File fle.close() #Update Progress bar self.progress_var.set( prog_incr*(i+1) ) self.mf.update_idletasks() self.progress_var.set( 0. ) self.mf.update_idletasks()
def extractRamanSpc(path, bg_path=False, combine_statics=False): '''Takes all .spc files from a directory and creates Raman_Spectrum object for each and also background subtracts, if specified .spc files must be directly exported at time of measurement. If .wdf file was re-opened with WiRE and then saved as .spc, use old code ('2017-04-14_Spectra_Class') Plots ASCII table with relevant metadata. Set table=False to omit this Also plots table for background files if user specifies bg_table = True''' '''Actual power values for each % laser power in μW. Measured on 09/05/2017.''' print('\nGathering .spc (meta)data...\n') p532 = { 0.0001: 0.01, 0.05: 4.75, 0.1: 12.08, 0.5: 49.6, 1.0: 88.1, 5.0: 666., 10.0: 1219., 50.0: 5360., 100.0: 9650. } p633 = { 0.0001: 0.01, 0.05: 1., 0.1: 2., 0.5: 10., 1.0: 20., 5.0: 112., 10.0: 226., 50.0: 1130., 100.0: 2200. } p785 = { 0.0001: 0.17, 0.05: 8.8, 0.1: 19.1, 0.5: 47.8, 1.0: 104., 5.0: 243., 10.0: 537., 50.0: 1210., 100.0: 2130. } powerConverter = { 532: p532, 633: p633, 785: p785 } #Assigns each laser power dictionary to the appropriate wavelength. os.chdir(path) spcFiles = [f for f in os.listdir('.') if f.endswith('.spc')] spectra = [] for n, spcFile in enumerate(spcFiles): filename = spcFile[:-4] #Removes extension from filename string #print(filename) f = spc.File(spcFile) #try: # f = spc.File(spcFile) #Create File object from .spc file #except: # print(filename) # f = spc.File(spcFile) #Create File object from .spc file metadata = {} fLogDict = {} fDicts = [f.__dict__, f.log_dict] newFDicts = [metadata, fLogDict] for dictN, fDict in enumerate(fDicts): for k in list(fDict.keys()): i = fDict[k] #print('%s (%s) = %s (%s)' % (k, type(k), i, type(i))) if type(k) == bytes: k = k.decode() if type(i) == bytes: try: i = i.decode() except Exception as e: #print(e) continue newFDicts[dictN][k] = i #print('%s (%s) = %s (%s)' % (k, type(k), i, type(i))) laserWl = int( fLogDict['Laser'][7:10] ) #Grabs appropriate part of laser wavelength entry from log and converts to integer (must be 3 characters long) if 'Laser_power' in list(fLogDict.keys()): laserPower = float( fLogDict['Laser_power'][13:-1] ) #Grabs numeric part of string containing laser power info and converts to float else: laserPower = 'Undefined' if laserPower in [0.0001, 0.05, 0.1, 0.5, 1.0, 5.0, 10.0, 50.0, 100.0]: absLaserPower = float( powerConverter[laserWl][laserPower] ) / 1000 #Returns absolute laser power (in mW), given laser wavelength and % laser power. else: absLaserPower = 'Undefined' #To avoid errors if laser power is not recorded correctly integrationTime = float(fLogDict['Exposure_time'][6:]) accumulations = fLogDict['Accumulations'].split(': ')[1] wavenumbers = f.x #Pulls x data from spc file nScans = int( metadata['fnsub'] ) #Number of Raman spectra contained within the spc file (>1 if file contains a kinetic scan) ramanIntensities = np.array([f.sub[i].y for i in range(nScans) ]) #Builds list of y data arrays if absLaserPower != 'Undefined': absRamanIntensities = [ old_div( (spectrum * 1000), (absLaserPower * integrationTime * float(accumulations))) for spectrum in ramanIntensities ] else: absRamanIntensities = ['N/A'] * nScans if nScans == 1: ramanIntensities = ramanIntensities[ 0] #Reduces to single array if not a kinetic scan absRamanIntensities = absRamanIntensities[0] #Also for this spectra.append( Raman_Spectrum(filename, metadata, laserWl, laserPower, absLaserPower, integrationTime, accumulations, nScans, wavenumbers, ramanIntensities, absRamanIntensities)) #except Exception as e: # print 'Something went wrong with %s:' % filename # print e # continue return spectra
def __import_data(self): if self.file_names is None: self.file_names = glob.glob(self.directory + '*.' + self.file_extension) self.file_list = pd.DataFrame(self.file_names, columns=['file_name'], index=np.arange(len(self.file_names))) self.file_list['x_coded'] = np.zeros(len(self.file_names), dtype=int) self.file_list['y_coded'] = np.zeros(len(self.file_names), dtype=int) self.file_list['z_coded'] = np.zeros(len(self.file_names), dtype=int) if self.measurement_type in [ 'Raman_volume', 'Raman_x_scan', 'Raman_y_scan', 'Raman_z_scan', 'Raman_xy_scan', 'Raman_single_spectrum' ]: if self.measurement_type in [ 'Raman_volume', 'Raman_x_scan', 'Raman_xy_scan' ]: self.file_list.iloc[:, 1] = ( pd.to_numeric(self.file_list.iloc[:, 0].str.extract( r'__X_([-*\d*.*\d*]*)\__Y_', expand=False)) * self.coord_conversion_factor).astype(int) if self.measurement_type in ['Raman_volume', 'Raman_y_scan']: self.file_list.iloc[:, 2] = ( pd.to_numeric(self.file_list.iloc[:, 0].str.extract( r'__Y_([-*\d*.*\d*]*)\__Z_', expand=False)) * self.coord_conversion_factor).astype(int) if self.measurement_type in ['Raman_xy_scan']: self.file_list.iloc[:, 2] = ( pd.to_numeric(self.file_list.iloc[:, 0].str.extract( r'__Y_([-*\d*.*\d*]*)\__', expand=False)) * self.coord_conversion_factor).astype(int) if self.measurement_type in ['Raman_volume', 'Raman_z_scan']: self.file_list.iloc[:, 3] = ( pd.to_numeric(self.file_list.iloc[:, 0].str.extract( r'__Z_([-*\d*.*\d*]*)\__', expand=False)) * self.coord_conversion_factor).astype(int) self.file_list = self.file_list.sort_values( by=['z_coded', 'y_coded', 'x_coded']) self.file_list.index = pd.RangeIndex(len(self.file_list.index)) wavenumbers = np.fromfile(self.file_list['file_name'][0], sep=' ')[::2] intensities = np.zeros( (len(self.file_list.index), wavenumbers.size)) for index, curr_index in enumerate(tqdm(self.file_list.index)): intensities[index] = np.fromfile(self.file_list.iloc[index, 0], sep=' ')[1::2] # Inline_IR and LSM still have to get their own classes elif self.measurement_type == 'Inline_IR': spectrum_data = spc.File(self.file_list.iloc[0, 0]) number_of_spectra = len(spectrum_data.sub) wavenumbers = spectrum_data.x intensities = np.zeros((number_of_spectra, len(spectrum_data.x))) time_data = np.zeros(number_of_spectra) for index, curr_spec in enumerate(tqdm(spectrum_data.sub)): intensities[index, :] = curr_spec.y time_data[index] = curr_spec.subtime self.file_list = self.file_list.loc[self.file_list.index.repeat( number_of_spectra)].reset_index(drop=True) self.file_list.iloc[:, 1] = (pd.Series(time_data) * self.coord_conversion_factor).astype(int) # Is still experimental, especially correct coordinates are missing and # possibly not working for not square images elif self.measurement_type == 'LSM': # read first image to get image dimensions first_image = imageio.imread(self.file_list.iloc[0, 0]) pixels_per_image = np.shape(first_image)[0] * np.shape( first_image)[1] number_of_images = len(self.file_list.index) intensities = np.zeros((number_of_images * pixels_per_image, np.shape(first_image)[2]), dtype='uint8') z_coords = np.repeat(np.arange(number_of_images), pixels_per_image) x_coords = np.tile( np.repeat(np.arange(np.shape(first_image)[0]), np.shape(first_image)[1]), number_of_images) y_coords = np.tile( np.tile(np.arange(np.shape(first_image)[1]), np.shape(first_image)[0]), number_of_images) wavenumbers = np.arange(np.shape(first_image)[2]) for index, curr_file in enumerate(tqdm(self.file_list.iloc[:, 0])): intensities[index * pixels_per_image:(index + 1) * pixels_per_image, :] = np.reshape( imageio.imread(curr_file), (-1, 3)) self.file_list = pd.DataFrame(np.stack([ np.repeat(self.file_list.iloc[:, 0], pixels_per_image), x_coords, y_coords, z_coords ]).T, columns=self.file_list.columns) hyperspectral_image_index = pd.MultiIndex.from_frame( self.file_list.iloc[:, 1:4]) self.spectral_data = pd.DataFrame(intensities, index=hyperspectral_image_index, columns=np.around(wavenumbers, 2))