def combine_landmarks_sort(self, add_landmark_path): origin_landmarks = { elem.split('_landmarks.txt')[0]: elem for elem in os.listdir(self.input_path) if elem.endswith('.txt') } add_landmarks = { elem.split('_noface')[0]: elem for elem in os.listdir(add_landmark_path) if elem.endswith('.txt') } utility.create_dir(self.output_path) for key in add_landmarks.keys(): if key not in origin_landmarks.keys(): print("{} is not exists in original list".format(key)) continue add_landmark_file_path = "{}/{}".format(add_landmark_path, add_landmarks[key]) origin_landmarks_file_path = "{}/{}".format( self.input_path, origin_landmarks[key]) origin_data = utility.read_file(origin_landmarks_file_path) add_data = utility.read_file(add_landmark_file_path) origin_data += add_data origin_data = sorted(origin_data) #print(key, add_landmarks[key], origin_landmarks[key]) dst_combine_landmark_path = '{}/{}_add_landmarks.txt'.format( self.output_path, key) utility.write_into_file(origin_data, dst_combine_landmark_path)
def save(self, name='', directory=CONTROLLER_FOLDER, screenshot=True, **info): """ [CM]- SAVE() Saving out Controller geometry and its relevant info :param name:(string) File name :param directory:(string) default path to {$MAYA_USER_DIR}/{$CONTROLLER_FOLDER} :param screenshot (Boolean) if saving the screenshot to dist :param info: (Dict) extra properties to burn to meta data :return: """ # construct the file path for geo and json geo_path = util.join_file_dir(directory, name, 'ma') info_path = util.join_file_dir(directory, name, 'json') # create the directory folder to save util.create_dir(directory) # save geometry(prompt window appear if no selection) util.save_maya_file(geo_path) # save screenshot if screenshot: info['screenshot'] = util.save_screenshot(name, directory) # store Meta-data block to CM's dictionary(memory) info['name'] = name info['path'] = geo_path # append other information down here self[name] = info # [LAST STEP] save out info-block to json util.save_json_file(info, info_path)
def select_one_image_from_file(self, input_file, output_file, select_num): if not os.path.exists(input_file): print "{} is not exists".format(input_file) return utility.create_dir(output_file) counter = 1 for root_path, folder_path, filenames in os.walk(input_file): if len(filenames) > 0: if counter > select_num: break if filenames[0].endswith('.jpg') or filenames[0].endswith('.png') or \ filenames[0].endswith('.bmp') or filenames[0].endswith('.JPG'): image_path = '{}/{}'.format(root_path, filenames[0]) dst_image_name = str(counter).zfill(5) dst_path = '{}/{}.jpg'.format(output_file, dst_image_name) shutil.copy(image_path, dst_path) sys.stdout.write('{}/{}\r'.format(counter, select_num)) sys.stdout.flush() counter += 1
def __init__(self, input_folder_path="", dst_folder_path=""): if dst_folder_path != "": utility.create_dir(dst_folder_path) input_folder_path = input_folder_path.rstrip('/') self.input_folder_path = input_folder_path self.dst_folder_path = dst_folder_path
def backup_rails_database(): db_info = get_rails_db_info() create_dir(env.backups_path, env.release) with hide('running', 'stdout', 'stderr'): run("mysqldump -h %s -u %s -p%s %s > %s/%s/%s.dump" \ % (db_info.get('host'), db_info.get('user'), db_info.get('password'), \ db_info.get('database'), env.backups_path, env.release, env.app_name)) puts("mysqldump -h %s -u %s -p<PASSWORD> %s > %s/%s/%s.dump" \ % (db_info.get('host'), db_info.get('user'), db_info.get('database'), env.backups_path, env.release, env.app_name))
def create_work_dir(self): self.logger.info("===== SETUP INITIALIZATION =====") engine_conf = conf.get_engine_conf() if engine_conf is None: return data_dir = engine_conf["network_data_dir"] utility.remove_dir(data_dir) utility.create_dir(data_dir) for client in self.clients: client.create_work_dir(data_dir)
def extract_noface_image(self, image_list, root_path, dst_path): utility.create_dir(dst_path) f = open(image_list, 'r') data = f.read().splitlines() f.close() for index, elem in enumerate(data): utility.show_process_percentage(index, len(data), 50) srcimage_path = '{}/{}'.format(root_path, elem) if os.path.isfile(srcimage_path): dst_move_path = '{}/{}'.format(dst_path, elem.split('/')[-1]) shutil.move(srcimage_path, dst_move_path)
def rename_image_names(self, input_file, output_file, image_prefix): if not os.path.exists(input_file): print "{} is not exists".format(input_file) return utility.create_dir(output_file) counter = 1 for root_path, folder_path, filenames in os.walk(input_file): for elem in filenames: srcImage_path = '{}/{}'.format(root_path, elem) dst_name = str(counter).zfill(5) dst_path = '{}/{}-{}.jpg'.format(output_file, image_prefix, dst_name) shutil.copy(srcImage_path, dst_path) counter += 1 print("Done!!")
def train_model(model, train_dataset, validation_dataset, test_dataset, model_name, base_path): """ :param model: :param train_dataset: :param validation_dataset: :param model_name: name of the base model :return: """ EPOCHS = 4 steps_p_epoch = 5 # train_dataset.samples // train_dataset.batch_size +1 validation_steps = 5 # validation_dataset.samples // validation_dataset.batch_size +1 time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") print("Start at ", time) # Setup folder for evaluation process logs etc parent_dir = create_dir(base_path, time + "_" + model_name) callbacks = generate_callbacks(parent_dir) history = model.fit(train_dataset, epochs=EPOCHS, steps_per_epoch=steps_p_epoch, validation_data=validation_dataset, validation_steps=validation_steps, callbacks=callbacks) time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") print("Finished Training at ", time) evaluate_model(model, test_dataset, parent_dir, history) time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") print("Finished Evaluation at ", time)
def test(self): self.load() self.model.eval() print(len(self.loader_test)) utility.create_dir('./result/{}'.format(self.args.file_name)) for _, (lr, gt, file_name) in enumerate(self.loader_test): lr, _ = self.prepare(lr, gt) with torch.no_grad(): output = self.model(lr) for _num in range(output.shape[0]): tmp = utility.quantize(output[_num]) imageio.imwrite( './result/{}/'.format(self.args.file_name) + str(file_name[_num].numpy()) + '.png', np.array(tmp[0])) print('Img: {} saved to ./result/{}/...'.format( str(file_name[_num].numpy()) + '.png', self.args.file_name))
def sample(self, show=True): print("TESTING START...") input_rgb = next(self.sample_generator) feed_dic = {self.input_rgb: input_rgb} outputs_path = create_dir(self.options.checkpoints_path + '/output') step, rate = self.sess.run([self.global_step, self.learning_rate]) fake_image, input_gray = self.sess.run([self.sampler, self.input_gray], feed_dict=feed_dic) fake_image = postprocess(tf.convert_to_tensor(fake_image), colorspace_in='LAB', colorspace_out=COLORSPACE_RGB) stitch_images(input_gray, input_rgb, fake_image.eval(),outputs_path,self.options.dataset + "_" + str(step).zfill(5))
def select_certain_image_from_file(self, input_file, output_file, select_image, select_num): if not os.path.exists(input_file): print "{} is not exists".format(input_file) return utility.create_dir(output_file) counter = 1 for root_path, folder_path, filenames in os.walk(input_file): for elem in filenames: if elem == select_image: image_path = '{}/{}'.format(root_path, elem) dst_image_name = str(counter).zfill(5) dst_path = '{}/{}d.jpg'.format(output_file, dst_image_name) shutil.copy(image_path, dst_path) sys.stdout.write('{}/{}\r'.format(counter, select_num)) sys.stdout.flush() counter += 1
def trig_check2(trignum, **kwargs): savepath = kwargs.get('savepath', False) import numpy as np import matplotlib.pyplot as plt import gen_reader as gr import utility as ut trigdat = gr.wf_reader('/home/james/anaconda3/data/' + str(date) + '/lv/trig_' + str(trignum) + '.txt') # Calculate dt and find the accelerometer level during trigger window acc_sig, acc_sig_1 = [], [] j = 0 for i in range(np.shape(trigdat)[0]): if trigdat[i, 2] == 0: j = 0 if trigdat[i, 2] == 1: if j == 0: acc_sig.append(np.mean(acc_sig_1)) acc_sig_1.append(trigdat[i, 1]) j += 1 plt.figure('trig2') plt.clf() plt.plot(acc_sig[1:], 'bo', markersize=3) plt.title( str(date) + ' run' + str(trignum) + ' Average Trigger Signal while Laser Shutter Open') plt.xlabel('Trigger Number') plt.ylabel('Accelerometer Signal (V)') if savepath != False: ut.create_dir(savepath) plt.savefig(savepath + 'trig_' + str(trignum) + '_acc_sig.png') return acc_sig[1:]
def create_controller_folder(directory='', o=False): """ [Create/Set Controller Folder] Create a new Controller Folder, if directory not specified, {$MAYA_USER_DIR}/{$CONTROLLER_FOLDER} will be set as default. Use o=True flag to open up the controller folder in file explorer :param directory: (String) A directory to specify, non will create :param o: (Boolean) if Open this directory in file explorer """ # Controller folder variable could be altered: use global keyword to grant access global CONTROLLER_FOLDER if not directory: directory = CONTROLLER_FOLDER else: CONTROLLER_FOLDER = directory if util.create_dir(directory): print("[CONTROLLER FOLDER] -> Created path: %s" % directory) else: print("[CONTROLLER FOLDER] -> File Path Exists: %s" % directory) # with -o flag on, open up the folder in file explorer if o: print("[CONTROLLER FOLDER] -> Open=True") util.open_folder(directory)
def initialize(): # If no environment is set get out of here abort_if_no_environment() # Ensure the releases directory exists if (not exists(env.releases_path)): with cd (env.path): run("mkdir releases") # Ensure the shared directory exists if (not exists(env.shared_path)): create_dir(env.path, env.shared_directory_name) create_dir(env.path, "%s/%s" % (env.shared_directory_name, env.shared_config_directory_name)) create_dir(env.path, env.backups_directory_name) print green("Application directories set up at %s.\nYou can deploy the application using fab to:%s deploy." % (env.path, env.deploy_to)) if is_rails_project(): create_dir(env.path, "%s/%s" % (env.shared_directory_name, env.shared_bundle_directory_name)) create_dir(env.path, "%s/%s" % (env.shared_directory_name, env.shared_tmp_directory_name)) create_dir(env.path, "%s/%s" % (env.shared_directory_name, env.shared_logs_directory_name)) run ("touch %s/%s/%s/production.log" %(env.path, env.shared_directory_name, env.shared_logs_directory_name)) print yellow("Upload database.yml and other .yml files to %s/%s/%s." % (env.path, env.shared_directory_name, env.shared_config_directory_name))
def beam_profile(maindir, dx_in, imsave, **kwargs): # Define Keyword Arguments z_units = kwargs.get('z_units', 'standard') data_units = kwargs.get('data_units', 'standard') afters = kwargs.get('after', False) param_guess = kwargs.get('p0', 'find') param_guess2 = kwargs.get('p0_waist', 'find') zvals = kwargs.get('zvals', 'default') fitlim = kwargs.get('fitlim', 'full') stages = kwargs.get('stage_type', 'auto') # Import Modules import numpy as np import matplotlib.pyplot as plt import math from scipy.special import erf from scipy.optimize import curve_fit import pylab import os import utility as ut import gen_reader as gr # Create directory for imsave ut.create_dir(imsave) # Define fit function (erf for low to high power) def fit_erf(x, a, x_0, w): return (a / 2.) * (1 + erf((np.sqrt(2) * (x - x_0)) / w)) # Get the files in the directory and remove '.DS_Store' if it exists filedirs = os.listdir(maindir) filedirs.sort() # If all dx are the same if len(dx_in) == len(filedirs): dx = dx_in else: dx = np.zeros((len(filedirs), ), dtype=float) dx[:] = dx_in # Fit the data to get spot size for each z-position beam_width = np.zeros((len(filedirs), ), dtype=float) weights = np.zeros((len(filedirs), ), dtype=float) z = np.zeros((len(filedirs), ), dtype=int) after = np.zeros((len(filedirs), ), dtype=int) for filedir in filedirs: if stages == 'manual': if afters == True: pos, pows, z[filedirs.index(filedir)], after[filedirs.index( filedir)] = pow_ave(maindir + '/' + filedir, dx[filedirs.index(filedir)], data_units, zvals=zvals) if afters == False: pos, pows, z[filedirs.index(filedir)] = pow_ave( maindir + '/' + filedir, dx[filedirs.index(filedir)], data_units, zvals=zvals) if stages == 'auto': z[filedirs.index(filedir)] = np.float(filedir[-9:-4]) matrix = gr.reader(maindir + filedir, header=False) pos, pows = (.166E-3 / 25.) * matrix[:, 0], matrix[:, 1] if stages == 'profman': xstep, z[filedirs.index( filedir)] = filedir[-9:-4], filedir[-29:-24] matrix = gr.reader(maindir + filedir, header=False) pows = matrix[:, 0] pos = 1E-3 * np.arange(0, float(xstep) * len(pows), float(xstep)) # Normalize and reorder the data for low to high power pows_norm = pows / np.amax(pows) if pows_norm[0] > pows_norm[-1]: pows_norm = np.flipud(pows_norm) # Get initial parameter guesses if param_guess == 'find': param_guess = [1, 0, 0] # Guess for w bnds = ut.bound_finder(pows_norm, [.1, .9]) param_guess[2] = pos[bnds[1]] - pos[bnds[0]] for i in range(len(pows)): if pows_norm[i] <= .5: param_guess[1] = pos[i] continue else: if pows_norm[i] - .5 >= .5 - pows_norm[i - 1]: param_guess[1] = pos[i - 1] break else: break # Do the fit if fitlim == 'full': posf = pos pows_normf = pows_norm if fitlim != 'full': posf = pos[fitlim[0]:fitlim[1]] pows_normf = pows_norm[fitlim[0]:fitlim[1]] param, covar = curve_fit(fit_erf, posf, pows_normf, p0=param_guess) beam_width[filedirs.index(filedir)] = param[2] weights[filedirs.index(filedir)] = 1 / np.sqrt(covar[2, 2]) # Plot Fit x = np.linspace(0, pos[-1], 100) fit = fit_erf(x, param[0], param[1], param[2]) fig = plt.figure('profile') plt.clf() ax = fig.add_subplot(111) plt.plot(pos, pows_norm, 'bo', label='Data') plt.plot(x, fit, 'k--', label='Fit') plt.axis([0, 1.1 * np.amax(pos), 0, 1.25]) plt.xlabel('Razor Blade Position (mm)') plt.ylabel('Normalized Laser Power') plt.legend() bbox_props = dict(boxstyle='square', fc='.9', ec='k', alpha=1.0) fig_text = 'Spot Size: ' + repr(round( 1000. * param[2], 2)) + ' +/- ' + repr( round(1000 * np.sqrt(covar[2, 2]), 2)) + ' micron' #fig_text='Amplitude: '+repr(round(param[0],2))+'\nOffset: '+repr(round(param[1],2))+' mm'+'\nSpot Size: '+repr(1000*round(param[2]),3)+' micron' plt.text(.02, .97, fig_text, fontsize=10, bbox=bbox_props, va='top', ha='left', transform=ax.transAxes) if zvals == 'default': pylab.savefig(imsave + '/' + repr(z[filedirs.index(filedir)]) + '_fit.png') if zvals != 'default': pylab.savefig(imsave + '/' + repr(zvals[filedirs.index(filedir)]) + '_fit.png') plt.show() # Fit the beam widths to find beam waist # Define the fit function wlength = 572 # nm def fit_waist(z, w_0, f): z_0 = (math.pi * np.square(w_0)) / (wlength * 1E-6) return w_0 * np.sqrt(1 + np.square((z - f) / z_0)) # Switch to manual z vals if zvals != 'default': z = np.array(zvals) # Convert z-positions to array with 0 = lowest position and units are mm if z_units == 'standard': conv = 25.4 if z_units == 'mm': conv = 1 if z_units == 'micron': conv = .001 z = (z - z[0]) * conv # Set initial parameters for beam fit if param_guess2 == 'find': # Get initial parameter guesses param_guess2 = [] slope = (beam_width[1] - beam_width[0]) / (z[1]) theta = 2 * np.arctan(np.absolute(slope)) param_guess2.append(2 * (wlength * 1E-6) / (math.pi * theta)) param_guess2.append(-beam_width[0] / slope) # Normalize the weights weights_n = weights / np.amax(weights) # Do the fit param2, covar2 = curve_fit(fit_waist, z, beam_width, p0=param_guess2, sigma=weights_n) # Plot the fit and data z_cont = np.linspace(0, np.amax(z), 100) fit2 = fit_waist(z_cont, param2[0], param2[1]) fig = plt.figure('Beam Fit') plt.clf() ax = fig.add_subplot(111) plt.plot(z, beam_width, 'bo', label='Data') plt.plot(z_cont, fit2, 'k--', label='Fit') plt.axis([0, np.amax(z), 0, 1.25 * np.amax(beam_width)]) plt.xlabel('z (mm)') plt.ylabel('Spot Size (mm)') plt.legend() plt.errorbar(z, beam_width, xerr=None, yerr=1 / weights, fmt=None) bbox_props = dict(boxstyle='square', fc='.9', ec='k', alpha=1.0) fig_text = 'Beam Waist: ' + repr(round( 1000 * param2[0], 2)) + ' +/- ' + repr( round(1000 * np.sqrt(covar2[0, 0]), 2)) + ' micron \nWaist Pos: ' + repr(round( param2[1], 2)) + ' +/- ' + repr( round(np.sqrt(covar2[1, 1]), 2)) + ' mm' plt.text(.02, .97, fig_text, fontsize=10, bbox=bbox_props, va='top', ha='left', transform=ax.transAxes) pylab.savefig(imsave + '/beam_fit.png') plt.show()
def waist_fit(z, beam_width, weight, **kwargs): imsave = kwargs.get('savepath', False) disp = kwargs.get('print', False) # Import Modules import numpy as np import matplotlib.pyplot as plt import math from scipy.special import erf from scipy.optimize import curve_fit import utility as ut # Convert z-positions to array with 0 = lowest position and units are mm z = np.array(z) z = (z - z[0]) * (25.4 / 1000) # Define the fit function def fit_waist(z, w_0, f): z_0 = (math.pi * np.square(w_0)) / (572 * 1E-6) return w_0 * np.sqrt(1 + np.square((z - f) / z_0)) param_guess = [4E-3, np.mean(z)] # Normalize the weights weight = weight / np.amax(weight) # Do the fit param, covar = curve_fit(fit_waist, z, beam_width, p0=param_guess, sigma=weight) # Plot the fit and data z_cont = np.linspace(0, np.amax(z), 100) if flength == 'fit': fit = fit_waist(z_cont, param[0], param[1]) if flength != 'fit': fit = fit_waist(z_cont, param[0]) fig = plt.figure('Beam Fit') plt.clf() ax = fig.add_subplot(111) plt.plot(z, beam_width, 'bo', label='Data') plt.plot(z_cont, fit, 'k--', label='Fit') plt.axis([-.1, 1.1 * np.amax(z), 0, 1.25 * np.amax(beam_width)]) plt.xlabel('z (mm)') plt.ylabel('Spot Size (mm)') plt.legend() bbox_props = dict(boxstyle='square', fc='.9', ec='k', alpha=1.0) fig_text = 'Beam Waist: ' + ut.rnd(1000 * param[0], 2) + ' +/- ' + ut.rnd( 1000 * np.sqrt(covar[0, 0]), 2) + ' micron' plt.text(.02, .97, fig_text, fontsize=10, bbox=bbox_props, va='top', ha='left', transform=ax.transAxes) if imsave != False: ut.create_dir(imsave) plt.savefig(imsave + '/beam_fit.png') if disp == True: print('w0: ' + ut.rnd(1000 * param[0], 2) + ' um\nz0: ' + ut.rnd((math.pi * np.square(1000 * param[0])) / (572 * 1E-3), 2) + ' um\nf: ' + ut.rnd(param[1], 2) + ' mm') plt.show()
def prof_solo(profnum, z, **kwargs): # Define kwargs imsave = kwargs.get('savefile', 'none') fitrange = kwargs.get('fit_range', 'full') xstep = kwargs.get('xstep', 'auto') units = kwargs.get('units', 'microns') # Import modules import numpy as np import matplotlib.pyplot as plt import math from scipy.special import erf from scipy.optimize import curve_fit import pylab import os import gen_reader as gr import utility as ut # Define fit function (erf for low to high power) def fit_erf(x, a, x_0, w, offset): return (a / 2.) * (1 + erf((np.sqrt(2) * (x - x_0)) / w)) + offset # Read in data from file if xstep == 'auto': matrix = gr.reader('/home/chris/anaconda/data/' + str(date) + '/lv/prof' + str(profnum) + '/prof' + str(profnum) + '_amp25_zpos_micron_' + z + '.txt', header=False) pos, pows = (.166E-3 / 25.) * matrix[:, 0], matrix[:, 1] if xstep != 'auto': matrix = gr.reader('/home/chris/anaconda/data/' + str(date) + '/lv/profman' + str.zfill(profnum, 2) + '/profman' + str.zfill(profnum, 2) + '_z-pos-' + units + str.zfill(z, 5) + '_x-step-' + units + str.zfill(xstep, 5) + '.txt', header=False) pows = matrix[:, 0] pos = 1E-3 * np.arange(0, float(xstep) * len(pows), float(xstep)) if units == 'minches': pos = pos * 25.4 # Make position array and power array (normalized low to high power) if pows[0] > pows[-1]: pows_norm = np.flipud(np.array(pows)) / np.amax(np.array(pows)) else: pows_norm = np.array(pows) / np.amax(np.array(pows)) # Get initial parameter guesses param_guess = [1, 0, 0, 0] # Guess for w bnds = ut.bound_finder(pows_norm, [.1, .9]) param_guess[2] = pos[bnds[1]] - pos[bnds[0]] # Guess for x_0 for i in range(len(pows)): if pows_norm[i] <= .5: param_guess[1] = pos[i] continue else: if pows_norm[i] - .5 >= .5 - pows_norm[i - 1]: param_guess[1] = pos[i - 1] break else: break # Do the fit if fitrange != 'full': param, covar = curve_fit(fit_erf, pos[fitrange[0]:fitrange[1]], pows_norm[fitrange[0]:fitrange[1]], p0=param_guess) if fitrange == 'full': param, covar = curve_fit(fit_erf, pos, pows_norm, p0=param_guess) # Plot the fits x = np.linspace(0, np.amax(pos), 100) fit = fit_erf(x, param[0], param[1], param[2], param[3]) fig = plt.figure('laser_prof') plt.clf() ax = fig.add_subplot(111) plt.plot(pos, pows_norm, 'bo', label='Data') plt.plot(x, fit, 'k--', label='Fit') plt.axis([0, 1.1 * np.amax(pos), 0, 1.25]) plt.xlabel('Razor Blade Position (mm)') plt.ylabel('Normalized Laser Power') plt.legend() bbox_props = dict(boxstyle='square', fc='.9', ec='k', alpha=1.0) fig_text = 'Spot Size: ' + ut.rnd(1000 * param[2], 2) + ' +/- ' + ut.rnd( 1000 * np.sqrt(covar[2, 2]), 2) + ' micron' #fig_text='Amplitude: '+repr(round(param[0],2))+'\nOffset: '+repr(round(param[1],2))+' mm'+'\nSpot Size: '+repr(1000*round(param[2]),3)+' micron' plt.text(.02, .97, fig_text, fontsize=10, bbox=bbox_props, va='top', ha='left', transform=ax.transAxes) if imsave != 'none': ut.create_dir(imsave) plt.savefig(imsave + 'beam_profile_' + str.zfill(z, 5) + '.png') plt.show() return param[2], np.sqrt(covar[2, 2]), pos, pows_norm
def create_work_dir(self, data_dir): work_dir = "{}/{}".format(data_dir, self.host) utility.create_dir(work_dir)
def fitter1d(func, data, param_0, **kwargs): # Define Keyword Arguments col = kwargs.get('color', 'Black') fitlim = kwargs.get('fitlim', 'full') fig = kwargs.get('fig', 'default') disp_param = kwargs.get('d_param', False) savepath = kwargs.get('savepath', False) label = kwargs.get('label', '') numpts = kwargs.get('numpts', 5) # Import Modules import numpy as np import matplotlib.pyplot as plt from scipy.optimize import curve_fit import utility as ut # Slice data to get frames/region of interest if fitlim != 'full': # Find index for upper fit limit j = -1 for i in data[0, :]: j = j + 1 if i < fitlim: last_wave = i else: a = abs(fitlim - last_wave) b = abs(i - fitlim) if a > b: lim_index = j break else: lim_index = j - 1 break data = data[:, 0:lim_index] # Do the fit param, sigma = curve_fit(func, data[0, :], data[1, :], p0=param_0) # Make a more finely spaced x data for fit plot xfit = np.linspace(np.amin(data[0, :]), np.amax(data[0, :]), numpts * np.shape(data)[1]) # Plot fit and data if fig == 'default': plt.figure('Fitter') else: plt.figure(fig) plt.clf() plt.plot(data[0, :], data[1, :], 'bo', label='Data') # Dynamically create a plot command with as many parameters as needed plt_str = 'plt.plot(xfit,func(xfit,' p_txt = '' for i in range(len(param)): if i == 0: plt_str += 'param[%d]' % i if disp_param != False: p_txt += disp_param[i] + ': ' + scinot(param[i]) else: plt_str += ',param[%d]' % i if disp_param != False: p_txt += '\n' + disp_param[i] + ': ' + scinot(param[i]) plt_str += '),"--",color=col,linewidth=2,label="Model")' exec(plt_str) if disp_param != False: textbox(p_txt, [.75, .8]) plt.legend() if savepath != False: ut.create_dir(savepath) plt.savefig(savepath + 'fit_' + label + '.png') return param