def __init__(self, args): input_path = args['input'] if not os.path.exists(input_path): raise FileNotFoundError(f'{input_path} does not exist') # get capture object self.cap = self.get_video(input_path) # get total number of frames self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT)) # get buffer size self.buffer_size = args['buffer'] # handle size parameter self.handle_size(args['size']) # get name of file filename = self.get_filename(input_path) # get output output = args['output'] # get final dir self.output_dir = output + filename + '/' # create dictionary of video writers self.input_videos = {} self.video_writers = {} # determine options for program self.handle_option(args['option'], args['read']) # initiate average and edit class self.stabiliser = Stabiliser(self.total_frames, self.size) self.ma = MovingAverage(self.size, False, False, args['buffer']) self.fe = FrameEditor() self.plt = Plotter(self.output_dir) # creates background model class using mixture of gradients self.backSub = cv2.createBackgroundSubtractorMOG2()
def create_sinogram(self, img): self.space = img step_angle = math.radians(self.step_angle) center = int(self.space.shape[0] / 2) radius = center - 5 actual_angle = 0 sinogram = [] for step in range(self.steps): emitter = ( center + int(radius * np.cos(actual_angle)), center + int(radius * np.sin(actual_angle)), ) selected_detector_angle = math.radians(180 - self.spread / 2) + actual_angle detector_step = math.radians(self.spread / (self.detectors_count - 1)) measurements = [] for j in range(self.detectors_count): detector = ( center + int(radius * np.cos(selected_detector_angle)), center + int(radius * np.sin(selected_detector_angle)), ) selected_detector_angle += detector_step path = Bresenham.bresenham_line(emitter, detector) measurements.append(self.space[path[:, 0], path[:, 1]].mean()) sinogram.append(measurements) actual_angle += step_angle Plotter.plotSinogram(sinogram) return np.array(sinogram)
def analyze(guess, y0, ode_type): func = ode_func_map[ode_type] to_estimate_init_values = {'guess': guess, 'y0': [y0, ]} estimator = ParameterEstimator( self.experiments, to_estimate_init_values, func) sol_ideal, sol_guess, sol_y0 = estimator.get_ideal_solution(func) options = copy.deepcopy(self.options) options['title'] = "System and " + \ ode_type + " model response to " + self.signalInstance + " signal" options['legend']['blue'] = "System response" options['legend']['orange'] = ode_type + " model response" Plotter.draw([self.t, [self.sol, sol_ideal]], options=options) Utility.checkProperty('model', self.data) Utility.checkProperty(self.signalInstance, self.data['model']) '''if not 'model' in self.data: self.data['model'] = {} if not self.signalInstance in self.data['model']: self.data['model'][self.signalInstance] = {}''' self.data['model'][self.signalInstance][ode_type] = { "initial": { "guess": guess, "y0": [y0], }, "estimated": { "guess": sol_guess.tolist(), "y0": sol_y0.tolist(), }, }
def __init__(self, params): self.batchSize = params["batch_size"] self.volSize = params["vol_size"] self.iterationCount = params["iter_count"] self.queueSize = params["queue_size"] self.shiftRatio = params["shift_ratio"] self.rotateRatio = params["rotate_ratio"] self.histogramShiftRatio = params["histogram_shift_ratio"] self.dataPath = params["data_path"] self.netPath = params["net_path"] self.phase = params["phase"] self.phaseSubPath = self.phase + "/" self.dataQueue = multiprocessing.Queue(self.queueSize) self.plotter = Plotter() self.plotter.initDataAndLabel2D(interval=20) if self.phase == "deploy": # scan pass else: # load all nodules and groundTruths dataProcess = multiprocessing.Process(target=self.dataProcessor, args=(self.dataQueue, )) dataProcess.daemon = True dataProcess.start()
def pipeline_2(self): def __get_all_class_scores(jsons): depth_class_scores = {} classes = [] for k in jsons: depth_class_scores[k] = jsons[k]["classScores"] for cl in depth_class_scores[k]: if cl not in classes: classes.append(cl) eval_dict = {} for k in depth_class_scores: eval_dict[k] = [] for cl in classes: eval_dict[k].append(depth_class_scores[k][cl]) return eval_dict, classes # depth_list = [[1.0, 0.75], [0.75, 0.5], [0.5, 0.25], [0.25, 0.0]] depth_dict = { 'very_close': [1.0, 0.75], 'close': [0.75, 0.5], 'far': [0.5, 0.25], 'very_far': [0.25, 0.0] } jsons = self.load_all_jsons_per_exp(depth_dict) # depth_MIOUs = self.__get_all_MIOUs(jsons) eval_dict, classes = __get_all_class_scores(jsons) print(eval_dict) Plotter.save_class_accuracy(eval_dict=eval_dict, class_names=classes, img_path="tmp.png")
def pipeline_3(self): json = self.load_exp_json() class_score_dict = json["classScores"] miou = json["averageScoreClasses"] avg_accuracy = json["averageAccuracy"] sorted_by_value = sorted(class_score_dict.items(), key=lambda kv: kv[1], reverse=True) class_score_dict = {tup[0]: tup[1] for tup in sorted_by_value} class_score_dict_w_color = {} for k in class_score_dict: class_score_dict_w_color[k] = {} class_score_dict_w_color[k]["score"] = class_score_dict[k] for l in labels: if l.name == k: color = np.array(l.color, dtype=np.float64) color = np.divide(color, 255) class_score_dict_w_color[k]["color"] = color title = "Class Accuracy " plot_folder = self.exp_obj.custom_eval_dir plot_path = plot_folder + "/class_avg_" + self.eval_dataset + ".png" Plotter.save_class_accuracy_new(class_score_dict_w_color, title, miou, avg_accuracy, plot_path)
def testing(self, dataset, testing_x, testing_y, widget): testing_x = testing_x label_testing = numpy.argmax(testing_y, axis=1) batch_size = 200 plotter = Plotter(dataset) predict = numpy.zeros((10000, 10)) predict_label = numpy.zeros(10000) completed = 0 for start in range(0, len(testing_x), batch_size): print(start) completed = completed + 2 widget.progress_bar.setValue(completed) x_batch = testing_x[start:start + batch_size] predict[start:start + batch_size] = self.test(x_batch) predict_out = self.output(predict) pandas.DataFrame(predict).to_csv("../output_testing.csv") pandas.DataFrame(predict_out).to_csv("../output_testing_2.csv") accuracy = numpy.mean(predict_out == label_testing) print(accuracy) plotter.plot_testing(x_batch, predict[start:start + batch_size], widget.list_result) widget.acc_label.setText(str(accuracy))
def do_experiment(self): self.obj.set_u_fcn(self.u_func) signalParams = params['signals'][self.signalInstance] self.sol, self.t = self.obj.calcODE() self.u = self.u_func(0, self.t) options = copy.deepcopy(self.options) options['title'] = "Experiment with " + \ self.signalInstance.replace('_', ' ') + " signal" options['legend']['blue'] = "Response" options['legend']['orange'] = "Input" Plotter.draw([self.t, [self.sol, self.u]], options=options) Utility.checkProperty('experiment', self.data) Utility.checkProperty('sig_params', self.data) Utility.checkProperty(self.signalInstance, self.data['sig_params']) self.data['experiment'][self.signalInstance] = { "guess": [self.obj.lin_par_1, self.obj.lin_par_2, self.obj.nonlin_par_1, self.obj.nonlin_par_2], "y0": [self.obj.y0], } for prop in signalParams.keys(): self.data['sig_params'][self.signalInstance][prop] = signalParams[prop] or None return self
def __init__(self) : possible_years = [int(i) for i in os.listdir(os.getcwd() + "\\logs\\")] self.plotter = Plotter(possible_years) self.window = Tk() self.window.title("Reading Process Progress") self.window.configure(background=self.COLOR2) # self.window.grid_rowconfigure(1, minsize=20) self.window.grid_rowconfigure(4, minsize=10) self.window.grid_columnconfigure(2, minsize=100) self.label1 = Label(self.window, text="Aggregate:", bg=self.COLOR2, fg=self.COLOR1) self.label1.grid(column=1, row=0) btnCompareAverage = Button(self.window, text="average year by year", command=self.plotter.compareAverages) btnCompareAverage.grid(column=2, row=1) self.label2 = Label(self.window, text="Year specific:", bg=self.COLOR2, fg=self.COLOR1) self.label2.grid(column=1,row=2) self.selectedYear = StringVar(self.window) self.selectedYear.set(possible_years[-1]) # default value yearSelection = OptionMenu(self.window, self.selectedYear, *possible_years, command = self.yearEntered) yearSelection.grid(column=1, row=3) btnTimeline = Button(self.window, text="timeline of reading", command=self.plotter.plotTimeLine) btnTimeline.grid(column=2, row=3) btnAllTrajectories = Button(self.window, text="all trajectories", command=self.plotter.plotTrajectories) btnAllTrajectories.grid(column=3, row=3) btnplotAverageTrajectories = Button(self.window, text="average trajectories", command=self.plotter.plotAverageTrajectories) btnplotAverageTrajectories.grid(column=4, row=3)
def executeSimplePerceptron(): #fileParser = FileParser("./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_and_or.txt") #open from arguments fileParser = FileParser("./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_ocr.txt") #open from arguments #fileParser = FileParser('./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_test.txt') #open from arguments #fileParser = FileParser('./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_test_with_testing_data.txt') #open from arguments #fileParser = FileParser('./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_test_with_same_testing_data.txt') #open from arguments #fileParser = FileParser('./workspaceFacu/RedesNeuronales-TP1/src/OCR/input_martin.txt') #open from arguments parameters = fileParser.parseInputFile() #function = Exponential(0.5) #function = Identity() function = Sign() VERBOSE = True SHUFFLE_TRAINING_SET = True neuralAlgorithm = SimplePerceptron(parameters, function, not SHUFFLE_TRAINING_SET, VERBOSE) print 'ALGORITHM - Start' neuralAlgorithm.train() print 'ALGORITHM - Finish' trainingInformation = neuralAlgorithm.getTrainingInformation() errorFileName = './/..//graphics//error - ' + parameters.objective validationFileName = './/..//graphics//validation - ' + parameters.objective testingFileName = './/..//graphics//testing - ' + parameters.objective SAVE_TO_FILE = True SHOW = True plotter = Plotter(errorFileName, validationFileName, testingFileName, not SAVE_TO_FILE) plotter.plot(trainingInformation, SHOW)
def __init__(self, infoRun, data = ''): self.infoRun = infoRun self.SetEnvironment(self.infoRun) self.data = data counter = 0 # Apply selection cut for bck in self.backgrounds: self.listOfSelectors.append(Selector(bck, self.savepath)) counter += 1 if (self.data != ''): self.dataSelector = Selector(self.data, self.savepath) # == Draw histograms # Parse selectors and other parameters to the Plotter class p = Plotter(self.listOfSelectors, self.dataSelector, self.Histos, self.colors) p.SetSavePath(self.savepath) p.SetAnnotations(self.Annotations) p.DrawHistos() # ===== Compute the cross-section # == Set attributes and parameters and compute the final result self.SetParameters('MuonPt') self.PrintXsection('MuonPt') return
def display_sma(df, symbol, metric, ws=10, ycs=None, save_path=None): vals = df.loc[symbol, metric] df_vals = pd.DataFrame(pd.concat([vals], keys=[symbol], names=['Symbol'])) df_sma = sma(df_vals, ws) smas = df_sma.loc[symbol, metric] df_pct_sma = pct_sma(df_vals, window_sizes=[ws], standard=True) psmas = df_pct_sma.loc[symbol, f'{metric}_pct_sma_{ws}'] vals = vals / vals[vals.first_valid_index()] smas = smas / smas[smas.first_valid_index()] x1 = pd.DataFrame({metric: vals, 'sma': smas}) x2 = pd.DataFrame({'standard pct sma': psmas}) plotter = Plotter() yax_labels = [f'indexed {metric}, sma', 'standard pct sma'] colors = [[(0.6, 0.13, 0.79), (0.79, 0.5, 0.13)], [(0.35, 0.35, 0.35)]] hcolors = [(0, 0, 1), (0, 0, 0)] plotter.stacked_plot(x1, x2, yax_labels=yax_labels, title=f'{symbol} {metric} SMA', ycs=ycs, colors=colors, hcolors=hcolors, save_path=save_path)
def compareDistancesWithSignalStrength(self): (Distances, Xs, Ys) = self.calculateDistanceFromCenterPointsToEachPoseReturningXYs() """ [ [Grid0 to P1, Grid0 to P2, Grid0 to P3, ... , Grid0 to Pn] [Grid1 to P1, Grid1 to P2, Grid1 to P3, ... , Grid1 to Pn] ... [Gridn to P1, Gridn to P2, Gridn to P3, ... , Gridn to Pn] ] """ global R RSSIofEachPoint = R """ [ RSSI of P1, RSSI of P2, RSSI of P3, ... , RSSI of Pn ] """ coefficientMatrix = [] for gridPoint in Distances: coefficientMatrix.append(self.calculateSimilarityScoreOfAGridPoint(gridPoint, RSSIofEachPoint)) PL = Plotter() #PL.printCompleteMapInColor([Xs, Ys, coefficientMatrix]) maximumCoefficient = coefficientMatrix.index(max(coefficientMatrix)) coefficientMatrix[maximumCoefficient] = 900 Xs.extend(X) Ys.extend(Y) coefficientMatrix.extend(R) PL.printCompleteMapInColor([Xs, Ys, coefficientMatrix])
def modelConstruct(self, options=None): train_X, train_y = self.train test_X, test_y = self.test shapes_X = train_X.shape self.model = Sequential() self.model.add( LSTM(self.LSTM_units, input_shape=(shapes_X[1], shapes_X[2]))) self.model.add(Dense(self.Dense_units)) self.model.compile(loss='mean_squared_error', optimizer='adam') self.history = self.model.fit(train_X, train_y, epochs=self.epochs, batch_size=self.batch_size, validation_data=(test_X, test_y), verbose=self.enable_verbose, shuffle=False) Plotter.draw([ None, [self.history.history['loss'], self.history.history['val_loss']] ], options=options)
def visitStatFor(self, ctx) -> str: start = self.visit(ctx.expr(0)) end = self.visit(ctx.expr(1)) step = self.visit(ctx.expr(2)) batch = Points() batch.setcolor(self.color) for t in np.arange(start, end, step): self.t = t x = self.visit(ctx.expr(3)) y = self.visit(ctx.expr(4)) x *= self.scale_x y *= self.scale_y rot_x = x*math.cos(self.rot) + y*math.sin(self.rot) rot_y = y*math.cos(self.rot) - x*math.sin(self.rot) x = rot_x + self.origin_x y = rot_y + self.origin_y batch.addpoint(x, y) Plotter.draw_points(batch) return f"Drew points"
def train(self): caffe.set_device(0) caffe.set_mode_gpu() solver = caffe.SGDSolver(self.netPath + "solver.prototxt") if len(self.snapshotFilename) != 0: solver.restore(self.netPath + self.snapshotPath + self.snapshotFilename) baseIter = solver.iter plotter = Plotter() plotter.initLossAndAccu(baseIter, self.iterationCount, self.netPath) plotter.initResult(interval=50) for i in range(self.iterationCount - baseIter): solver.step(1) # plot loss and accu loss = solver.net.blobs["loss"].data accu = solver.test_nets[0].blobs["accu"].data plotter.plotLossAndAccu(loss, accu) # plot result and label data = solver.net.blobs["data"].data data = np.squeeze(data[0, 0, :, :, :]) result = solver.net.blobs["conv_i64c2o64_output_1"].data result = np.squeeze(result[0, 1, :, :, :]) # print(result) label = solver.net.blobs["label"].data label = np.squeeze(label[0, 0, :, :, :]) plotter.plotResult(data, label, result)
def display_vwpc(df, symbol, metric, ws=10, ycs=None, save_path=None): vals = df.loc[symbol, metric] volvals = df.loc[symbol, 'Volume'] df_vals = pd.concat([vals, volvals], axis=1, keys=[metric, 'Volume']) df_vals['Symbol'] = symbol df_vals = df_vals.reset_index().set_index(['Symbol', 'Date']) df_vwpc = vwpc(df_vals, window_sizes=[ws], standard=False) vwpcvals = df_vwpc.loc['JPM', f'{metric}_vwpc_{ws}'] vals = vals / vals[vals.first_valid_index()] weighted = vals * volvals weighted = (weighted - weighted.min()) / (weighted.max() - weighted.min()) x1 = pd.DataFrame({metric: vals, 'norm vwp': weighted}) x2 = pd.DataFrame({'vwpc': vwpcvals}) plotter = Plotter() colors = [[(0.6, 0.13, 0.79), (0.79, 0.5, 0.13)], [(0.35, 0.35, 0.35)]] hcolors = [(0, 0, 1), (0, 0, 0)] yax_labels = [f'indexed {metric}, norm vwp', 'vwpc'] plotter.stacked_plot(x1, x2, yax_labels=yax_labels, title=f'{symbol} {metric} VWPC', colors=colors, hcolors=hcolors, ycs=ycs, save_path=save_path)
def deconstruct_sinogram(self, sinogram): height, width = self.space.shape result_img = np.zeros((width, height)) step_angle = math.radians(self.step_angle) actual_angle = 0 center = int(width / 2) radius = center - 5 for i in range(self.steps): w, h = height - 5, width - 5 emitter = ( center + int(radius * np.cos(actual_angle)), center + int(radius * np.sin(actual_angle)), ) selected_detector_angle = math.radians(180 - self.spread / 2) + actual_angle detector_step = math.radians(self.spread / (self.detectors_count - 1)) for j in range(self.detectors_count): detector = (center + int(radius * np.cos(selected_detector_angle)), center + int(radius * np.sin(selected_detector_angle))) selected_detector_angle += detector_step path = Bresenham.bresenham_line(emitter, detector) for p in path: result_img[p[0]][p[1]] += sinogram[i][j] actual_angle += step_angle Plotter.plotSinogram(np.array(result_img)[50:-50, 50:-50]) return np.array(result_img)[50:-50, 50:-50]
def object_free_movements(self): sol, t = self.obj.calcODE() options = copy.deepcopy(self.options) options['title'] = "Object free movements" Plotter.draw([t, sol], options=options) return self
def cmp_benchmark(self, symbol, sd=dt.datetime(2008, 1, 1), ed=dt.datetime(2009, 12, 31), sv=1e5, bench_quantity=1e3, commission=9.95, impact=0.001, should_plot=False, labels=None, title=None, save_path=None): df_trades = self.testPolicy(symbol=symbol, sd=sd, ed=ed, sv=sv) sp = msim.compute_portvals(df_trades, start_val=sv, commission=commission, impact=impact) bp = self.benchmark_policy(symbol, sd=sd, ed=ed, sv=sv, quantity=bench_quantity, commission=commission, impact=impact) if labels is None: labels = ['benchmark', 'manual'] # combine policies into single dataframe df_cmp = pd.concat([bp, sp], axis=1) df_cmp.columns = labels # optionally plot comparison if should_plot: plotter = Plotter() yax_labels = [f'indexed portfolio value', 'shares'] colors = [[(0, 1, 0), (1, 0, 0)], [(0.35, 0.35, 0.35)]] df_pos = df_trades.cumsum() df_cmp['benchmark'] = df_cmp['benchmark']/bp.iloc[0] df_cmp['manual'] = df_cmp['manual']/sp.iloc[0] ycs = [[3, ['>', 0, 1]], [3, ['<', 0, 1]]] hcolors = [(0, 0, 1), (0, 0, 0)] plotter.stacked_plot(df_cmp, df_pos, yax_labels=yax_labels, title=title, ycs=ycs, colors=colors, hcolors=hcolors, yc_data=df_trades, save_path=save_path) return df_cmp
def get_noise_stats(self, data_dir, model, sdevs, approach, x_raw_f, render=False): stats = {} img_probs = {} for sd in sdevs: image_datasets, loaders = self.initialize_data(data_dir, sdev=sd) X_test, Y_test, X_test_f = self.load_all_data(loaders, kind='test') # plot train data with labels if render: Plotter.plot_data(image_datasets, X_test, Y_test, kind='test') # calculate statistics stats[sd] = self.compute_statistics(model, X_test_f, x_raw_f, approach) img_probs[sd] = self.get_image_probabilities( model, X_test_f, x_raw_f) if approach == 2 else self.get_class_probabilities( model, X_test_f, x_raw_f) return stats, img_probs
def plot(self, predict): """ :param predict: トレーニングしたモデルで予測した結果。one_hot表現ではなく、確率が入っている。 :return: """ p = Plotter() p.plot_and_show(self.d.inputs_org, predict, self.NUM_OF_EACH_CLASS_DATA, self.NUM_OF_CLASSES)
def plotStationET(): station = request.form.getlist('station[]') print(station) date = request.form.get('date') print(date) p = Plotter() figdata_png = p.plot_hourly_eto_by_station_date(int(station[0]), date) return render_template('img.html', result=figdata_png)
def render_test_data(self, m, x): for i, model in enumerate(m): for x_test in x: # apply the model y_pred = self.predict(i + 1, model, x_test, x) if i == 2: Plotter.plot_sample(x_test.reshape(16, 16), y_pred.reshape(16, 16))
def _plot(eval_results, eval_targets): plotter = Plotter(eval_results, eval_targets) plotter.plot_arousal() plotter.show() plotter.plot_valence() plotter.show()
def __init__(self, objective_function, configuration, result_file_name, skip_frames=0): super().__init__(objective_function, configuration[0], configuration[1], result_file_name) self.max_beta = configuration[2] self.absorption_coefficient = configuration[3] self.result_file_name = result_file_name self.factor = objective_function.factor self.skip_frames = skip_frames self.plotter = Plotter(objective_function, 'Firefly')
def plot_configuration(config_name, policy_names): #set the regrets setting = Setting() regrets = setting.set_regrets() num_regrets = len(regrets) #load experiments loader = DataLoader() experiments = loader.load_config_experiments(config_name, policy_names) num_exp = len(list(experiments.values())[0]) #retrieve configuration config = list(experiments.values())[0][0].config #retrive time horizon N = config.N #retrive policies policies = [] for exp_list in experiments.values(): policies = policies + [exp_list[0].policy] num_policies = len(policies) #compute the regrets regret = np.zeros((num_exp, num_policies, num_regrets, N)) for pol_idx in range(num_policies): curr_policy = policies[pol_idx] for exp_idx in range(num_exp): curr_exp = experiments[curr_policy.name][exp_idx] pulls = curr_exp.pulls for reg_idx in range(num_regrets): curr_regr = regrets[reg_idx] regret[exp_idx, pol_idx, reg_idx, :] = curr_regr.compute_regret( pulls, curr_exp.config) mean_regret = np.mean(regret, axis=0) #varianza del regret std_regret = np.std(regret, axis=0) error = 2 * np.true_divide(std_regret, num_exp**0.5) #plot the regrets titles = [] labels = [] filename = config_name + '_' for policy in policies: filename = filename + policy.name + '-' labels = labels + [policy.name] filename = filename[:-1] + '_' for reg_type in regrets: titles = titles + [reg_type.description] filename = filename + reg_type.name + '-' plt = Plotter() plt.plot_regret(mean_regret, error, None, titles, labels, filename[:-1])
def calcReg(): params = request.form.getlist('params[]') p = Plotter() # print(params) # print(p.get_regression_result(params)) if (len(params) > 0): return jsonify(p.get_regression_result(params)) else: return jsonify(p.get_regression_result())
def calculate(self, symbol=None): quotes_list = symbol.get_EoD_quotes(self.opts.get('fromdate'), self.opts.get('todate')) self.price_list = quotes_list Plotter.get_plot_buffer().append((self.name, self.price_list)) return self
def visualizePredictions(self, training_x, training_y, test_x, test_y): #Input 1 or 2 D. Output 1 D. assert (training_x.shape[1] == 1 or training_x.shape[1] == 2), \ "Invalid Dimensions for Plotting Results - Input: %d" %(training_x.shape[1]) plotter = Plotter() plotter.plotPrediction(self, training_x, training_y, self.norm_test_x, self.norm_test_y) plotter.plotExpertsPrediction(self, test_x, test_y) plotter.plotExpertsCenters(self, training_x, training_y) plotter.plotGaussians(self, training_x, training_y)
def __init__(self, objective_function, configuration, result_file_name, skip_frames=0): super().__init__(objective_function, configuration[0], configuration[1], result_file_name) self.max_trials = configuration[2] self.skip_frames = skip_frames self.plotter = Plotter(objective_function, 'Bees')
def calculate(self, symbol=None): quotes_list = symbol.get_EoD_quotes( self.opts.get('fromdate'), self.opts.get('todate') ) self.price_list = quotes_list Plotter.get_plot_buffer().append((self.name, self.price_list)) return self
def getSignalOverBackground(analysis,region,period,cut,**kwargs): doDataDriven = kwargs.pop('doDataDriven',True) scalefactor = kwargs.pop('scalefactor','event.gen_weight*event.pu_weight*event.lep_scale*event.trig_scale') nl = 3 sigMap = getSigMap(nl) intLumiMap = getIntLumiMap() mergeDict = getMergeDict(period) channelBackground = getChannelBackgrounds(period) channels, leptons = getChannels(nl) saves = '%s_%s_%iTeV' % (analysis,region,period) ntuples = getNtupleDirectory(analysis,region,period) plotter = Plotter(region,ntupleDir=ntuples,saveDir=saves,period=period,rootName='plots_sOverB',mergeDict=mergeDict,scaleFactor=scalefactor,datadriven=doDataDriven) plotter.initializeBackgroundSamples([sigMap[period][x] for x in channelBackground[region+'datadriven' if doDataDriven else region]]) plotter.initializeDataSamples([sigMap[period]['data']]) plotter.setIntLumi(intLumiMap[period]) sig = 0. sigErr2 = 0. bg = 0. bgErr2 = 0. for b in plotter.backgrounds: val, err = plotter.getNumEntries(cut,b,doError=True) if b=='WZJets': sig += val sigErr2 += err**2 else: bg += val bgErr2 += err**2 sigErr = sigErr2**0.5 bgErr = bgErr2**0.5 return sig/bg if bg else -1.
def __init__(self,image,plotfile,plotarea,shadescale): Plotter.__init__(self,plotfile) # set up self.plotarea = plotarea self.spacing = 5 self.image = image self.scaleImage() shadelevels = self.detectShades(shadescale) print "auto leveled for ", shadescale, " to ", shadelevels self.shades = { MODES.EW: (0,int(shadelevels[0])), #70 MODES.NS: (0,int(shadelevels[1])), #100 MODES.NWSE: (0,int(shadelevels[2])), #150 MODES.NESW: (0,int(shadelevels[3]))} #195
def __init__(self): QtGui.QDialog.__init__(self) self.setupUi(self) self.datreader = DataReader() self.Plotter = Plotter() self.directory = os.getcwd() self.WorkingD_label.setText(self.directory) self.ShowFile_PB.clicked.connect(self.show_file_start) # shows first lines in the textbrowser self.ReadSets_PB.clicked.connect(self.read_set) # reads all files that start with lineEdit and creates a dict in the Sets_Dict[set][file][column] self.PlotFile_PB.clicked.connect(self.plotfile) self.MAV_slider.valueChanged.connect(self.mav_valuechanged) self.MAV_slider.sliderReleased.connect(self.mav_released) self.LP_slider.sliderReleased.connect(self.lp) self.LP_slider.valueChanged.connect(self.lp_valuechanged) self.HP_slider.sliderReleased.connect(self.hp) self.HP_slider.valueChanged.connect(self.hp_valuechanged) #self.CutZeros.clicked.connect(self.cut_zeros_filedict) self.PlotColumn_PB.clicked.connect(self.plotcolumn) self.Clear_PB.clicked.connect(self.clear) self.Export_PB.clicked.connect(self.export) self.FFT_PB.clicked.connect(self.fft) self.ReadLabBook.clicked.connect(self.readlabbook) self.MAVEdit.returnPressed.connect(self.mav_released) self.MVAREdit.returnPressed.connect(self.mvar) self.MMMINEdit.returnPressed.connect(self.mmmin) self.Corr_PB.clicked.connect(self.correlate) self.Select_PB.clicked.connect(self.open_filedialog) self.Pyro_PB.clicked.connect(self.read_pyro) self.Log_PB.clicked.connect(self.log_scale) self.Sets_Dict = dict() # contains [set1][file1][column1] - the data self.Files_Dict = dict() # contains [filename 1]: 'set-filename' self.Columns_Dict = dict() # contains[set-filename-column]: same
def __init__(self, parent): ''' Constructor ''' self.parent = parent self.portfolioManager = PortfolioManager() self.plotter = Plotter(parent)
def getYieldsErrors(analysis,region,period,cut,**kwargs): doDataDriven = kwargs.pop('doDataDriven',True) scalefactor = kwargs.pop('scalefactor','event.gen_weight*event.pu_weight*event.lep_scale*event.trig_scale') nl = 3 sigMap = getSigMap(nl) intLumiMap = getIntLumiMap() mergeDict = getMergeDict(period) channelBackground = getChannelBackgrounds(period) channels, leptons = getChannels(nl) saves = '%s_%s_%iTeV' % (analysis,region,period) ntuples = getNtupleDirectory(analysis,region,period) plotter = Plotter(region,ntupleDir=ntuples,saveDir=saves,period=period,rootName='plots_statUnc',mergeDict=mergeDict,scaleFactor=scalefactor,datadriven=doDataDriven) plotter.initializeBackgroundSamples([sigMap[period][x] for x in channelBackground[region+'datadriven' if doDataDriven else region]]) plotter.initializeDataSamples([sigMap[period]['data']]) plotter.setIntLumi(intLumiMap[period]) yields = {} for chan in ['eee','eem','mme','mmm']: yields[chan] = {} chanCut = '{0} && channel=="{1}"'.format(cut,chan) sig = 0. sigErr2 = 0. bg = 0. bgErr2 = 0. for b in plotter.backgrounds: val, err = plotter.getNumEntries(chanCut,b,doError=True) if b=='WZJets': sig += val sigErr2 += err**2 else: bg += val bgErr2 += err**2 sigErr = sigErr2**0.5 bgErr = bgErr2**0.5 data, dataErr = plotter.getDataEntries(chanCut,doError=True) dataErr2 = dataErr**2 yields[chan]['sig'] = [sig, sigErr] yields[chan]['bg'] = [bg, bgErr] yields[chan]['data'] = [data, dataErr] yields['wz'] = {} for i in ['sig','bg','data']: tot = sum([yields[chan][i][0] for chan in ['eee','eem','mme','mmm']]) totErr = sum([yields[chan][i][1]**2 for chan in ['eee','eem','mme','mmm']])**0.5 yields['wz'][i] = [tot, totErr] return yields
def main(): plotter = Plotter("out.png", "The plot", "some", "thing", 10, 60) plotter.addPlotItem("Source1", "#F01020", dataSource1) plotter.addPlotItem("Source2", "#201020", dataSource2) #plotter.begin() stopEvent = threading.Event() tweeter = TwitterPlotBot('api/app key', 'api/app secret', 'access key', 'access secret', '#pause', '#resume', plotter, stopEvent, '@navin_bhaskar', 500, False) time.sleep(120) print "Plotting..." tweeter.start() time.sleep(1900) print "Stopping it....." stopEvent.set() tweeter.join()
def getBackgroundEstimation(analysis,region,period,cut,**kwargs): doDataDriven = kwargs.pop('doDataDriven',True) scalefactor = kwargs.pop('scalefactor','event.gen_weight*event.pu_weight*event.lep_scale*event.trig_scale') nl = 3 sigMap = getSigMap(nl) intLumiMap = getIntLumiMap() mergeDict = getMergeDict(period) channelBackground = getChannelBackgrounds(period) channels, leptons = getChannels(nl) saves = '%s_%s_%iTeV' % (analysis,region,period) ntuples = getNtupleDirectory(analysis,region,period) bgChannels = [sigMap[period][x] for x in channelBackground[region+'datadriven' if doDataDriven else region]] plotter = Plotter(region,ntupleDir=ntuples,saveDir=saves,period=period,rootName='plots_bgEstimation',mergeDict=mergeDict,scaleFactor=scalefactor,datadriven=doDataDriven) plotter.initializeBackgroundSamples(bgChannels) plotter.initializeDataSamples([sigMap[period]['data']]) plotter.setIntLumi(intLumiMap[period]) estimates = {} for chan in channels: thisCut = '{0} && channel=="{1}"'.format(cut,chan) estimates[chan] = {} obs, obsErr = plotter.getDataEntries(thisCut,doError=True) obsErr2 = obsErr**2 dd = 0. ddErr2 = 0. mc = 0. mcErr2 = 0. for bg in bgChannels + ['datadriven']: val, err = plotter.getNumEntries(thisCut,bg,doError=True) if bg in ['datadriven']: dd += val ddErr2 += err**2 else: mc += val mcErr2 += err**2 fromMC = [obs - mc, (obsErr2 + mcErr2)**0.5] fromDD = [dd, ddErr2**0.5] estimates[chan]['mc'] = fromMC estimates[chan]['datadriven'] = fromDD estimates['total'] = {} estimates['total']['mc'] = [sum([estimates[x]['mc'][0] for x in channels]), sum([estimates[x]['mc'][1]**2 for x in channels])**0.5] estimates['total']['datadriven'] = [sum([estimates[x]['datadriven'][0] for x in channels]), sum([estimates[x]['datadriven'][1]**2 for x in channels])**0.5] return estimates
def __init__(self): QtGui.QMainWindow.__init__(self) self.plotHolder = Plotter() self.layout = QtGui.QVBoxLayout() self.data = 0 self.dataStr = 0 self.filePath = None self.filePath2 = 0 self.setWindowTitle("FlightMadness") self.setWindowIcon(QtGui.QIcon('phyton.ico')) self.setupUi(self)
def __init__(self): plott = Plotter() QtGui.QMainWindow.__init__(self) self.setWindowIcon(QtGui.QIcon('phyton.ico')) self.setupUi(self) self.fit = Fitter() self.gen = Generator() self.plot = Plotter() self.fitted_args = [] self.chi2 = None self.chi2Error = 0.5
def calculate(self, symbol=None): """ TODO : A lot of things in this method and methods stemming from this will change when we store data in a database instead of pickling them; make the code better when that happens """ opts = self.opts quotes_list = None if opts.get('symbolmode') == 'EoD': if symbol.is_attribute_known(self.name): available_from, available_to = symbol.attribute_known_for(self.name) opts['fromdate'] = ( available_from if available_from < opts['fromdate'] else opts['fromdate'] ) opts['todate'] = ( available_to if available_to > opts['todate'] else opts['todate'] ) data_fromdate = (opts.get('fromdate') - timedelta(days=(opts.get('param')-2))) quotes_list = symbol.get_EoD_quotes(data_fromdate, opts.get('todate')) elif opts.get('symbolmode') == 'intraday': quotes_list = symbol.get_intraday_quotes() pass self.rsi_list = self.get_RSI(quotes_list) Plotter.get_plot_buffer().append((self.name, self.rsi_list)) # need to write rsi_list to a file symbol.write_attrib_to_file(self.name, self.rsi_list) return self
def initialize(self): self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn) self.setWidgetResizable(True) self.widget = QtGui.QWidget() self.setWidget(self.widget) self.vbox = QtGui.QVBoxLayout() self.vbox.setSpacing(15) self.accel = Plotter('Beschleunigung', [-20, 20], 3, ['g', 'r', 'y']) self.gyro = Plotter('Gyroskop', [-360, 360], 3, ['g', 'r', 'y']) self.parser = Parser() self.current_file = Testfile('') self.vbox.addWidget(self.accel) self.vbox.setAlignment(self.accel, QtCore.Qt.AlignTop) self.vbox.addWidget(self.gyro) self.vbox.setAlignment(self.gyro, QtCore.Qt.AlignTop) self.vbox.addStretch() self.widget.setLayout(self.vbox)
def main(): """ This is the enrty point for our application, "TwitterBot" """ global plotter plotter = Plotter(config.config["output file"], # The output file name config.config["title"], # Title of the plot config.config["xlabel"], # X axis label config.config["ylabel"], # Y axis label config.config["samples"], # Max number of samples to be taken config.config["Log Interval"], # Log interval ) # Now that we have the plotter, it is time to add items to it for callback in CallBacks.callbacks: plotter.addPlotItem(callback[0], callback[2], callback[1]) twitterBot = TwitterPlotBot(config.config["consumer key"], config.config["consumer secret"], config.config["access token"], config.config["access token secret"], config.config["stop plot cmd"], config.config["resume plot cmd"], plotter, stopEvent, config.config["screen id"], config.config["Tweet Interval"], False) # Wait for some time until we have atleast one data point to plot time.sleep(config.config["Log Interval"]) twitterBot.start() while True: pass
def plot(self): plotter = Plotter() plotter.plot_alive_cells(self.state_history) plotter.plot_objects_count(self.rules, self.state_history)
''' Created on 6 de abr de 2016 @author: manoe ''' from Plotter import Plotter if __name__ == '__main__': p = Plotter([2,2], [-3,1]) print(p.valor(2))
class InteractiveEPF(): def __init__(self, parent): ''' Constructor ''' self.parent = parent self.portfolioManager = PortfolioManager() self.plotter = Plotter(parent) def initUI(self, expReturn=.0100): self.portfolioManager.initEPF() self.portfolioManager.runEPF(expReturn=expReturn) self.plotter.initRanges(self.portfolioManager.portfolios, self.portfolioManager.companies) self.plotter.initPlot(self.portfolioManager.portfolios, self.portfolioManager.companies) self.plotter.initChart(self.portfolioManager.portfolios, self.portfolioManager.companies) #self.plotter.pack() axcolor = 'white' axRet = pyplot.axes([0.25, 0.032, 0.65, 0.02], axisbg=axcolor) self.sRet = Slider(axRet, 'Expected Return', 0.0, self.plotter.ymax, valinit=expReturn, valfmt='%1.4f') self.sRet.on_changed(self.expReturnChange) axRet = pyplot.axes([0.25, 0.008, 0.65, 0.02], axisbg=axcolor) self.tRet = Slider(axRet, 'Risk-Free Return', 0.0, self.plotter.ymax, valinit=0.0, valfmt='%1.4f') self.tRet.on_changed(self.tanChange) def addPortfolio(self, portfolio): self.portfolioManager.addPortfolio(portfolio) def expReturnChange(self, expRet): expRet = self.sRet.val tanRet = self.tRet.val self.portfolioManager.runEPF(expReturn=float(expRet), freeReturn=float(tanRet)) self.plotter.updateExpRetPlot(self.portfolioManager.portfolios) self.plotter.updateExpRetChart(self.portfolioManager.portfolios) def tanChange(self, expRet): expRet = self.sRet.val tanRet = self.tRet.val self.portfolioManager.runEPF(expReturn=float(expRet), freeReturn=float(tanRet)) self.plotter.updateTanPlot(self.portfolioManager.portfolios) self.plotter.updateTanChart(self.portfolioManager.portfolios) def show(self): pyplot.show()
def modeling(self, country_name): # create dest dir if not exists(self.destdir): makedirs(self.destdir) root.info('Infer for %s', country_name) time = datetime.now() # build location where clause for succeeding queries boundary = None if self.poly: boundary = PolyParser.poly_to_polygon(self.poly) where_clause = "st_intersects(l.way, st_transform(st_geomfromtext('" + boundary.wkt + "',4269),3857))" elif self.bpoly: boundary = wkt.loads(self.bpoly) where_clause = "st_intersects(l.way, st_transform(st_geomfromtext('" + boundary.wkt + "',4269),3857))" else: where_clause = "st_distance(l.way, (select way from planet_osm_polygon where osm_id = " + str( self.ssid) + ")) <= 300000" # do inference for each voltage level all_circuits = [] all_substations = dict() all_generators = dict() equipment_points = [] length_found_lines = 0 for voltage_level in self.voltage_levels.split('|'): (length_found_lines, equipment_points, generators, substations, circuits) = self.inference_for_voltage( voltage_level, where_clause, length_found_lines, equipment_points, all_substations, all_generators, boundary) all_generators.update(generators) all_substations.update(substations) all_circuits.extend(circuits) root.info('Total length of all found lines is %s meters', str(length_found_lines)) equipments_multipoint = MultiPoint(equipment_points) map_centroid = equipments_multipoint.centroid logging.debug('Centroid lat:%lf, lon:%lf', map_centroid.x, map_centroid.y) all_circuits = Transnet.remove_duplicates(all_circuits) root.info('Inference took %s millies', str(datetime.now() - time)) transnet_instance.export_to_json(all_circuits) partition_by_station_dict = None population_by_station_dict = None cities = None if self.load_estimation: root.info('Start partitioning into Voronoi-portions') load_estimator = LoadEstimator(all_substations, boundary) partition_by_station_dict, population_by_station_dict = load_estimator.partition() cities = load_estimator.cities if self.topology: root.info('Plot inferred transmission system topology') plotter = Plotter(self.voltage_levels) plotter.plot_topology(all_circuits, equipments_multipoint, partition_by_station_dict, cities, self.destdir) root.info('CSV generation started ...') csv_writer = CSVWriter(all_circuits) csv_writer.publish(self.destdir + '/csv') root.info('CIM model generation started ...') cim_writer = CimWriter(all_circuits, map_centroid, population_by_station_dict, self.voltage_levels) cim_writer.publish(self.destdir + '/cim') # for circuit in all_circuits: # for line in circuit.members[1:-1]: # if line.id not in self.all_lines: # self.length_all += line.length # self.all_lines[line.id] = line.id # # root.info('All lines length without duplicates %s', str(self.length_all / 1000)) # # self.length_all = 0 # for circuit in all_circuits: # for line in circuit.members[1:-1]: # self.length_all += line.length # # root.info('All lines length with duplicates %s', str(self.length_all / 1000)) # # for circuit in all_circuits: # sts = [circuit.members[0], circuit.members[-1]] # for st in sts: # if st.id not in self.all_stations: # self.all_stations[st.id] = 1 # else: # self.all_stations[st.id] += 1 # # root.info('All Stations %s', str(self.all_stations)) if validate: validator = InferenceValidator(self.cur) if boundary: all_stations = all_substations.copy() all_stations.update(all_generators) validator.validate2(all_circuits, all_stations, boundary, self.voltage_levels) else: validator.validate(self.ssid, all_circuits, None, self.voltage_levels) root.info('Took %s in total', str(datetime.now() - time))
class MeinDialog(QtGui.QDialog, Dlg): def __init__(self): QtGui.QDialog.__init__(self) self.setupUi(self) self.datreader = DataReader() self.Plotter = Plotter() self.directory = os.getcwd() self.WorkingD_label.setText(self.directory) self.ShowFile_PB.clicked.connect(self.show_file_start) # shows first lines in the textbrowser self.ReadSets_PB.clicked.connect(self.read_set) # reads all files that start with lineEdit and creates a dict in the Sets_Dict[set][file][column] self.PlotFile_PB.clicked.connect(self.plotfile) self.MAV_slider.valueChanged.connect(self.mav_valuechanged) self.MAV_slider.sliderReleased.connect(self.mav_released) self.LP_slider.sliderReleased.connect(self.lp) self.LP_slider.valueChanged.connect(self.lp_valuechanged) self.HP_slider.sliderReleased.connect(self.hp) self.HP_slider.valueChanged.connect(self.hp_valuechanged) #self.CutZeros.clicked.connect(self.cut_zeros_filedict) self.PlotColumn_PB.clicked.connect(self.plotcolumn) self.Clear_PB.clicked.connect(self.clear) self.Export_PB.clicked.connect(self.export) self.FFT_PB.clicked.connect(self.fft) self.ReadLabBook.clicked.connect(self.readlabbook) self.MAVEdit.returnPressed.connect(self.mav_released) self.MVAREdit.returnPressed.connect(self.mvar) self.MMMINEdit.returnPressed.connect(self.mmmin) self.Corr_PB.clicked.connect(self.correlate) self.Select_PB.clicked.connect(self.open_filedialog) self.Pyro_PB.clicked.connect(self.read_pyro) self.Log_PB.clicked.connect(self.log_scale) self.Sets_Dict = dict() # contains [set1][file1][column1] - the data self.Files_Dict = dict() # contains [filename 1]: 'set-filename' self.Columns_Dict = dict() # contains[set-filename-column]: same def log_scale(self): print 'log_scale' f = self.Plotter.figure_list[int(self.CurrentFigureEdit.text())] ax = f.axes[int(self.ax_scale_edit.text())] if ax.get_yscale == 'linear': ax.set_yscale('log') print 'log' else: ax.set_yscale('linear') plt.title('') def read_pyro(self): print 'read_pyro' filelist = list() filelist = [f for f in os.listdir(self.directory) if f.startswith(self.lineEdit.text())] print filelist filelist = [os.path.join(self.directory, f) for f in filelist] cols_of_interest = [str(c).rstrip(' ').lstrip(' ') for c in self.ColsOfInterestEdit.text().split(',')] print cols_of_interest self.Sets_Dict[str(self.lineEdit.text())] = self.datreader.read_pyro(filelist, cols_of_interest) #self.cut_zeros_filedict() self.update_SetScroll() self.update_Files_Dict() self.update_FileScroll() self.update_Columns_Dict() self.update_ColumnScroll() print self.Sets_Dict.keys() def open_filedialog(self): files = str(QtGui.QFileDialog.getOpenFileName(None, QtCore.QString('Select File'), QtCore.QString(os.getcwd()),QtCore.QString('*.txt'))) print files self.lineEdit.setText(os.path.basename(files)) self.WorkingD_label.setText(os.path.dirname(files)) self.directory = os.path.dirname(files) def correlate(self): fnum = self.Plotter.plot_eval(self.Plotter.correlate, 0, int(self.CurrentFigureEdit.text()), self.InActiveFigure.isChecked(), self.SelectedRange.isChecked(), self.SubtractMean_PB.isChecked()) self.CurrentFigureEdit.setText(str(fnum)) def readlabbook(self): #self.HistoryEdit.insertPlainText(self.HistoryEdit.text()) print 'read labbook' lab_dict = self.datreader.get_labdict(str(self.lineEdit.text())) filelist = lab_dict.keys() print filelist path = self.directory filelist = [os.path.join(path, f) for f in filelist if f in os.listdir(path)] print filelist cols_of_interest = [str(c).rstrip(' ').lstrip(' ') for c in self.ColsOfInterestEdit.text().split(',')] print cols_of_interest self.Sets_Dict[str(self.lineEdit.text())] = self.datreader.read_files(filelist, cols_of_interest) #self.cut_zeros_filedict() lab_dict = self.datreader.get_labdict(str(self.lineEdit.text())) for f in self.Sets_Dict[str(self.lineEdit.text())].keys(): for info in lab_dict[f].keys(): self.Sets_Dict[str(self.lineEdit.text())][f][info] = lab_dict[f][info] self.update_SetScroll() self.update_Files_Dict() self.update_FileScroll() self.update_Columns_Dict() self.update_ColumnScroll() print self.Sets_Dict.keys() def mvar(self): fnum = self.Plotter.plot_eval(self.Plotter.mvar, int(self.MVAREdit.text()), int(self.CurrentFigureEdit.text()), self.InActiveFigure.isChecked(), self.SelectedRange.isChecked(), self.SubtractMean_PB.isChecked()) self.CurrentFigureEdit.setText(str(fnum)) def mmmin(self): fnum = self.Plotter.plot_eval(self.Plotter.mmmin, int(self.MMMINEdit.text()), int(self.CurrentFigureEdit.text()), self.InActiveFigure.isChecked(), self.SelectedRange.isChecked(), self.SubtractMean_PB.isChecked()) self.CurrentFigureEdit.setText(str(fnum)) def mav_released(self): #if not self.InActiveFigure.isChecked(): # self.MAVEdit.setText(str(self.MAV_slider.value())) fnum = self.Plotter.plot_eval(self.Plotter.mav, int(self.MAVEdit.text()), int(self.CurrentFigureEdit.text()), self.InActiveFigure.isChecked(), self.SelectedRange.isChecked(), self.SubtractMean_PB.isChecked()) self.CurrentFigureEdit.setText(str(fnum)) def fft(self): print 'fft' fnum = self.Plotter.plot_eval(self.Plotter.fft, 0, int(self.CurrentFigureEdit.text()), self.InActiveFigure.isChecked(), self.SelectedRange.isChecked(), self.SubtractMean_PB.isChecked()) self.CurrentFigureEdit.setText(str(fnum)) def export(self): self.Plotter.export(int(self.CurrentFigureEdit.text())) def clear(self): self.Sets_Dict = dict() self.update_SetScroll() self.Files_Dict = dict() self.update_FileScroll() self.Columns_Dict = dict() self.update_ColumnScroll() def lp_valuechanged(self): self.LPEdit.setText(str(self.LP_slider.value())) def lp(self): print 'mav' self.MAVEdit.setText(str(self.LP_slider.value())) def hp_valuechanged(self): self.HPEdit.setText(str(self.HP_slider.value())) def hp(self): print 'mav' self.MAVEdit.setText(str(self.HP_slider.value())) def mav_valuechanged(self): self.MAVEdit.setText(str(self.MAV_slider.value())) if self.InActiveFigure.isChecked(): fnum = self.Plotter.plot_eval(self.Plotter.mav, int(self.MAVEdit.text()), int(self.CurrentFigureEdit.text()), self.InActiveFigure.isChecked(), self.SelectedRange.isChecked(), self.SubtractMean_PB.isChecked()) self.CurrentFigureEdit.setText(str(fnum)) def plotcolumn(self): for col in self.ColumnScroll.selectedItems(): key = str(col.text()).split('::') col_data = self.Sets_Dict[key[0]][key[1]][key[2]] x_axis = self.Sets_Dict[key[0]][key[1]]['Zeit'] label = str(col.text()+ '') self.Plotter.plot_column(x_axis, col_data, int(self.CurrentFigureEdit.text()), label) # def cut_zeros_filedict(self): # print 'cut_zeros_filedict' # if self.CutZeros.isChecked() == True: # print 'checked' # for fd in self.Files_Dict.keys(): # self.Files_Dict[fd] = self.datreader.cutzeros_file_dict(self.Files_Dict[fd]) def plotfile(self): for f in self.FileScroll.selectedItems(): key = str(f.text()).split('::') print key title = str(f.text()) self.Plotter.plot_file(self.Sets_Dict[key[0]][key[1]], [ str(c).rstrip(' ').lstrip(' ') for c in self.ColsOfInterestEdit.text().split(',')], int(self.CurrentFigureEdit.text()), title) def read_set(self): print 'read_set' filelist = list() filelist = [f for f in os.listdir(self.directory) if f.startswith(self.lineEdit.text())] print filelist filelist = [os.path.join(self.directory, f) for f in filelist] cols_of_interest = [str(c).rstrip(' ').lstrip(' ') for c in self.ColsOfInterestEdit.text().split(',')] print cols_of_interest self.Sets_Dict[str(self.lineEdit.text())] = self.datreader.read_files(filelist, cols_of_interest) #self.cut_zeros_filedict() self.update_SetScroll() self.update_Files_Dict() self.update_FileScroll() self.update_Columns_Dict() self.update_ColumnScroll() print self.Sets_Dict.keys() def update_ColumnScroll(self): print 'update_ColumnScroll' self.ColumnScroll.clear() for col in self.Columns_Dict.keys(): item = QtGui.QListWidgetItem() item.setText(col) self.ColumnScroll.addItem(item) def update_Columns_Dict(self): print 'update_FilesDict' cols_of_interest = [str(c).rstrip(' ').lstrip(' ') for c in self.ColsOfInterestEdit.text().split(',')] for s in self.Sets_Dict.keys(): # sets for f in self.Sets_Dict[s].keys(): #files for c in self.Sets_Dict[s][f].keys(): if c in cols_of_interest: self.Columns_Dict[s + '::' + f + '::' + c] = s + '::' + f + '::' + c def update_Files_Dict(self): print 'update_FilesDict' for s in self.Sets_Dict.keys(): # sets print s for f in self.Sets_Dict[s].keys(): #files print f self.Files_Dict[f] = str(s) + '::'+ str(f) #self.cut_zeros_filedict() def update_SetScroll(self): print 'update_SetScroll' self.SetScroll.clear() for key in self.Sets_Dict.keys(): item = QtGui.QListWidgetItem() item.setText(str(key)) self.SetScroll.addItem(item) def update_FileScroll(self): print 'update_FileScroll' self.FileScroll.clear() for key in self.Files_Dict.keys(): item = QtGui.QListWidgetItem() item.setText(str(self.Files_Dict[key])) self.FileScroll.addItem(item) def show_file_start(self): try: f = open(self.lineEdit.text()) s= '' for i in range(12): s = s+f.readline() self.textBrowser.setText(s) except: print 'Error in file read'
import array test = True if test: x = Sample( FileName = 'rootFiles/mtestReadoutAnalysis_siliconDigitPlots.root', Type = 'h', Sumw2 = False, Label = 'ReadoutAna_siliconTruthSanityPlots') print x x.Type2D = 'COLZ' x.LineColour = 4 samples = [x] plots = Plotter(samples) plots.PlotLegend = False # PER EVENT HISTOS fname = "plots/mtestReadoutAnalysis/siliconDigitPlots" # h_firstSiliconHitLayer plots.Print("rawTime", xtitle='time', ytitle='events', outname = fname + '/rawTime') # h_firstSiliconHitView plots.Print("f_scintTime", xtitle='hitTime', ytitle='events', outname = fname + '/f_scintTime') # h_firstSiliconHitView plots.Print("b_scintTime", xtitle='hitTime', ytitle='events', outname = fname + '/b_scintTime')
td.addLabelingIncremental("att", 4) td.reInit() RosDataAcquisition.rosBagLoadOdometry(odometryBag, odometryTopic, td, "pos", "att") # Load Timestamps into new td td_aligned.addLabelingIncremental("pos", 3) td_aligned.addLabelingIncremental("att", 4) td_aligned.reInit() RosDataAcquisition.rosBagLoadTimestampsOnly(timestampBag, timestampTopic, td_aligned) # Interpolate Data td.interpolateColumns(td_aligned, "pos", "pos") td.interpolateQuaternion(td_aligned, "att", "att") # Plotting plotterPos = Plotter(-1, [3, 1], "Position", ["", "", "time[s]"], ["x[m]", "y[m]", "z[m]"], 10000) plotterAtt = Plotter(-1, [4, 1], "Attitude", ["", "", "", "time[s]"], ["w", "x", "y", "z"], 10000) plotterPos.addDataToSubplotMultiple(td, "pos", [1, 2, 3], ["b", "b", "b"], ["", "", ""]) plotterAtt.addDataToSubplotMultiple(td, "att", [1, 2, 3, 4], ["b", "b", "b", "b"], ["", "", "", ""]) plotterPos.addDataToSubplotMultiple(td_aligned, "pos", [1, 2, 3], ["g", "g", "g"], ["", "", ""]) plotterAtt.addDataToSubplotMultiple(td_aligned, "att", [1, 2, 3, 4], ["g", "g", "g", "g"], ["", "", "", ""]) # Apply body and inertial if bodyTranslation != None and bodyRotation != None: td_aligned.applyBodyTransform("pos", "att", bodyTranslation, bodyRotation) if inertialTranslation != None and inertialRotation != None: td_aligned.applyBodyTransform("pos", "att", inertialTranslation, inertialRotation) plotterPos.addDataToSubplotMultiple(td_aligned, "pos", [1, 2, 3], ["r", "r", "r"], ["", "", ""]) plotterAtt.addDataToSubplotMultiple(td_aligned, "att", [1, 2, 3, 4], ["r", "r", "r", "r"], ["", "", "", ""]) if writeData:
#!/usr/bin/env python import sys,collections,gc,time from math import sqrt,sin,cos,acos,atan2,degrees,fabs,pow,modf,fmod from Plotter import Point,Lengths,Plotter def dash(x,y1,y2,slen): draw = True for y in range(int(y1+slen),int(y2),int(slen)): print "drawing to ",x,",",y, " ", draw v.drawLineTo(Point(x,y),draw) draw = not(draw) plotfile = open(sys.argv[1],'wb') startx = long(sys.argv[2]) v = Plotter(plotfile) #v.drawLineTo(v.pointFromLengths(Lengths(v.W+100,v.W+100)),False) c = (startx,200.0) for x in range(0,100,10): v.drawLineTo(Point(c[0]+x,c[1]),False) print "starting at ", c[0]+x,",",c[1] dash(c[0]+x,c[1],c[1]+200.0,10) v.reset() print ("done.")
0:{'name':'WW', 'colour':ROOT.TColor.GetColor(222,90,106), 'label':'WZ/WW'}, 1:{'name':'WZ', 'colour':ROOT.TColor.GetColor(222,90,106), 'label':''}, 2:{'name':'ZZ', 'colour':ROOT.TColor.GetColor(248,206,104), 'label':'ZZ'}, 3:{'name':'tt1l', 'colour':ROOT.TColor.GetColor(155,152,204), 'label':'t#bar{t} (1l)'}, 4:{'name':'tt2l', 'colour':ROOT.TColor.GetColor(160,160,220), 'label':'t#bar{t} (2l)'}, 5:{'name':'W1Jet', 'colour':ROOT.TColor.kGreen + 2, 'label':'W + jets'}, 6:{'name':'W2Jet', 'colour':ROOT.TColor.kGreen + 2, 'label':''}, 7:{'name':'W3Jet', 'colour':ROOT.TColor.kGreen + 2, 'label':''}, 8:{'name':'W4Jet', 'colour':ROOT.TColor.kGreen + 2, 'label':''}, 9:{'name':'DY1Jet', 'colour':ROOT.TColor.GetColor(222,90,106), 'label':'DY + jets'}, 10:{'name':'DY2Jet', 'colour':ROOT.TColor.GetColor(222,90,106), 'label':''}, 11:{'name':'DY3Jet', 'colour':ROOT.TColor.GetColor(222,90,106), 'label':''}, 12:{'name':'DY4Jet', 'colour':ROOT.TColor.GetColor(222,90,106), 'label':''}, # 4:{'name':'ttW', 'colour':ROOT.TColor.kGreen + 2, 'label':'t#bar{t}W'}, # 5:{'name':'ttZ', 'colour':ROOT.TColor.kGreen + 3, 'label':'t#bar{t}Z'}, 13:{'name':'tH_YtMinus', 'colour':ROOT.TColor.kRed + 3, 'label':'tH (y_{t}=-1)'}, # 7:{'name':'ttH', 'colour':ROOT.TColor.GetColor(248,206,104), 'label':'t#bar{t}H'}, # 8:{'name':'reducible', 'colour':ROOT.TColor.GetColor(250,202,255), 'label':'Reducible'}, # 100:{'name':'data', 'colour':1, 'label':'Data'}, # FIXME: 100? } p = Plotter(variables, sampleDict, fileName="BDT_training_mva.root", signalsampleIds=[13], datasampleIds=[100]) p.readTuples() p.makePlots(weight='bdt_evt_weight')
class Ui_MainWindow(QtGui.QMainWindow): def __init__(self): plott = Plotter() QtGui.QMainWindow.__init__(self) self.setWindowIcon(QtGui.QIcon('phyton.ico')) self.setupUi(self) self.fit = Fitter() self.gen = Generator() self.plot = Plotter() self.fitted_args = [] self.chi2 = None self.chi2Error = 0.5 #Funkcja odpowiedzialna za wywolanie funkcji tworzacej nowy wykres z klasy Plotter #oraz wstawienie go w GUI def DrawPlot(self): Plotter.dopasowana = self.checkBox_dopasowana.isChecked() Plotter.poczatkowa = self.checkBox_poczatkowa.isChecked() Plotter.dane = self.checkBox_dane.isChecked() Plotter.xlim_min = self.spinbox_zakresOd.value() Plotter.xlim_max = self.spinbox_zakresDo.value() self.tabWidget.removeTab(0) self.newTab = QtGui.QWidget() self.newTab.setObjectName(_fromUtf8("plot")) self.tabWidget.insertTab(0,self.newTab, _fromUtf8("Wykres")) self.tabWidget.setCurrentWidget(self.newTab) layout = QtGui.QVBoxLayout() fig = self.plot.plot(self.gen.returnX(),self.gen.returnY(),self.gen.returnYn(),self.fit.returnFittedData()) layout.addWidget(FigureCanvasQTAgg(fig)) self.newTab.setLayout(layout) print 'Plot created.' #Funkcja uruchamiana po uzyciu przycisku generujacego wykres w GUI #Odpowiedzialna za kolejne uruchomienie wszystkich funkcje z zaimportowanych klas def start(self): print 'Generating data...' #przekazanie danych ze spinboxow (z interfejsu) do generatora danych self.gen.getData(self.spinbox_amp.value(),self.spinbox_freq.value(),self.spinbox_ilePkt.value(),self.spinbox_rozrzut.value(),self.spinbox_przesuniecie.value(),self.spinbox_zakresOd.value(),self.spinbox_zakresDo.value()) # #uruchamianie kreatora self.gen.creator() #przekazywanie danych do fittera self.fit.getData(self.gen.returnX(),self.gen.returnYn()) chio = None oneMoreGuess = 0 #iteracyjne poszukiwanie odpowiedniej czestotliwosci, dobierane na podstawie porownania z wartoscia chi2 print "Fitting..." while ((chio == None) or (chio > self.chi2Error)) and (oneMoreGuess < self.spinbox_freq.maximum()): #dopasowywanie funkcji self.fit.fit(self.fit.guess(oneMoreGuess)) chio = Stats.chi(self.gen.returnY(),self.fit.returnFittedData()) oneMoreGuess += 0.1 self.chi2 = chio if self.chi2 <= self.chi2Error: print 'Fitting status: OK' else: print 'Fitting status: Failure' #wydrukowanie zfitowanych wartosci self.fitted_args = self.fit.printfitted_args() #tworzenie plottera print 'Drawing plot...' self.DrawPlot() #aktualizacja GUI self.UpdateGui() print 'All done.' print '-----------------' #Funkcja akutalizujaca informacje w gui def UpdateGui(self): self.chi_value.setText(str(round(self.chi2,6))) self.amp_value.setText(str(round(self.fitted_args[0],6))) self.freq_value.setText(str(round(self.fitted_args[1],6))) self.przes_value.setText(str(round(self.fitted_args[2],6))) #Funkcja inicjalizujaca spinboxy def initSpinBox(self): self.spinbox_amp.setValue(1) self.spinbox_freq.setValue(1) self.spinbox_rozrzut.setValue(0.1) self.spinbox_ilePkt.setValue(500) self.spinbox_zakresOd.setValue(0) self.spinbox_zakresDo.setValue(10) self.spinbox_przesuniecie.setValue(0) #Funkcje odpowiedzialne za tworzenie GUI def setupUi(self, MainWindow): MainWindow.setObjectName(_fromUtf8("MainWindow")) MainWindow.setFixedSize(914, 523) self.centralwidget = QtGui.QWidget(MainWindow) self.centralwidget.setObjectName(_fromUtf8("centralwidget")) self.tabWidget = QtGui.QTabWidget(self.centralwidget) self.tabWidget.setGeometry(QtCore.QRect(350, 30, 531, 371)) self.tabWidget.setObjectName(_fromUtf8("tabWidget")) self.tab = QtGui.QWidget() self.tab.setObjectName(_fromUtf8("tab")) self.tabWidget.addTab(self.tab, _fromUtf8("")) self.spinbox_rozrzut = QtGui.QDoubleSpinBox(self.centralwidget) self.spinbox_rozrzut.setGeometry(QtCore.QRect(190, 230, 62, 22)) self.spinbox_rozrzut.setObjectName(_fromUtf8("spinbox_rozrzut")) self.iloscPkt_label = QtGui.QLabel(self.centralwidget) self.iloscPkt_label.setGeometry(QtCore.QRect(70, 200, 81, 21)) self.iloscPkt_label.setObjectName(_fromUtf8("iloscPkt_label")) self.rozrzutPkt_label = QtGui.QLabel(self.centralwidget) self.rozrzutPkt_label.setGeometry(QtCore.QRect(70, 230, 101, 21)) self.rozrzutPkt_label.setObjectName(_fromUtf8("rozrzutPkt_label")) self.zakresOd_label = QtGui.QLabel(self.centralwidget) self.zakresOd_label.setGeometry(QtCore.QRect(70, 260, 71, 21)) self.zakresOd_label.setObjectName(_fromUtf8("zakresOd_label")) self.zakresDo_label = QtGui.QLabel(self.centralwidget) self.zakresDo_label.setGeometry(QtCore.QRect(230, 260, 21, 21)) self.zakresDo_label.setObjectName(_fromUtf8("zakresDo_label")) self.spinbox_zakresOd = QtGui.QDoubleSpinBox(self.centralwidget) self.spinbox_zakresOd.setGeometry(QtCore.QRect(160, 260, 62, 22)) self.spinbox_zakresOd.setObjectName(_fromUtf8("spinbox_zakresOd")) self.spinbox_zakresDo = QtGui.QDoubleSpinBox(self.centralwidget) self.spinbox_zakresDo.setGeometry(QtCore.QRect(250, 260, 62, 22)) self.spinbox_zakresDo.setObjectName(_fromUtf8("spinbox_zakresDo")) self.spinbox_ilePkt = QtGui.QSpinBox(self.centralwidget) self.spinbox_ilePkt.setGeometry(QtCore.QRect(190, 200, 61, 22)) self.spinbox_ilePkt.setObjectName(_fromUtf8("spinbox_ilePkt")) self.rozklad_label = QtGui.QLabel(self.centralwidget) self.rozklad_label.setGeometry(QtCore.QRect(70, 170, 161, 21)) self.rozklad_label.setObjectName(_fromUtf8("rozklad_label")) self.funkcja_label = QtGui.QLabel(self.centralwidget) self.funkcja_label.setGeometry(QtCore.QRect(70, 30, 161, 21)) self.funkcja_label.setObjectName(_fromUtf8("funkcja_label")) self.amplituda_label = QtGui.QLabel(self.centralwidget) self.amplituda_label.setGeometry(QtCore.QRect(70, 60, 61, 21)) self.amplituda_label.setObjectName(_fromUtf8("amplituda_label")) self.spinbox_amp = QtGui.QDoubleSpinBox(self.centralwidget) self.spinbox_amp.setGeometry(QtCore.QRect(190, 60, 62, 22)) self.spinbox_amp.setObjectName(_fromUtf8("spinbox_amp")) self.czestotliwosc_label = QtGui.QLabel(self.centralwidget) self.czestotliwosc_label.setGeometry(QtCore.QRect(70, 90, 70, 21)) self.czestotliwosc_label.setObjectName(_fromUtf8("czestotliwosc_label")) self.spinbox_freq = QtGui.QDoubleSpinBox(self.centralwidget) self.spinbox_freq.setGeometry(QtCore.QRect(190, 90, 62, 22)) self.spinbox_freq.setObjectName(_fromUtf8("spinbox_freq")) self.przesuniecie_label = QtGui.QLabel(self.centralwidget) self.przesuniecie_label.setGeometry(QtCore.QRect(70, 120, 61, 21)) self.przesuniecie_label.setObjectName(_fromUtf8("przesuniecie_label")) self.spinbox_przesuniecie = QtGui.QDoubleSpinBox(self.centralwidget) self.spinbox_przesuniecie.setGeometry(QtCore.QRect(190, 120, 62, 22)) self.spinbox_przesuniecie.setObjectName(_fromUtf8("spinbox_przesuniecie")) self.checkBox_poczatkowa = QtGui.QCheckBox(self.centralwidget) self.checkBox_poczatkowa.setGeometry(QtCore.QRect(70, 330, 131, 21)) self.checkBox_poczatkowa.setChecked(True) self.checkBox_poczatkowa.setObjectName(_fromUtf8("checkBox_poczatkowa")) self.checkBox_dopasowana = QtGui.QCheckBox(self.centralwidget) self.checkBox_dopasowana.setGeometry(QtCore.QRect(70, 350, 131, 21)) self.checkBox_dopasowana.setChecked(True) self.checkBox_dopasowana.setObjectName(_fromUtf8("checkBox_dopasowana")) self.checkBox_dane = QtGui.QCheckBox(self.centralwidget) self.checkBox_dane.setGeometry(QtCore.QRect(70, 370, 131, 21)) self.checkBox_dane.setChecked(True) self.checkBox_dane.setObjectName(_fromUtf8("checkBox_dane")) self.rysuj_label = QtGui.QLabel(self.centralwidget) self.rysuj_label.setGeometry(QtCore.QRect(70, 310, 161, 21)) self.rysuj_label.setObjectName(_fromUtf8("rysuj_label")) self.rysuj_button = QtGui.QPushButton(self.centralwidget) self.rysuj_button.setGeometry(QtCore.QRect(160, 400, 75, 23)) self.rysuj_button.setObjectName(_fromUtf8("rysuj_button")) self.dopasowane_label = QtGui.QLabel(self.centralwidget) self.dopasowane_label.setGeometry(QtCore.QRect(350, 400, 111, 21)) self.dopasowane_label.setObjectName(_fromUtf8("dopasowane_label")) self.amp_dopasowane_label = QtGui.QLabel(self.centralwidget) self.amp_dopasowane_label.setGeometry(QtCore.QRect(350, 420, 61, 21)) self.amp_dopasowane_label.setObjectName(_fromUtf8("amp_dopasowane_label")) self.freq_dopasowane_label = QtGui.QLabel(self.centralwidget) self.freq_dopasowane_label.setGeometry(QtCore.QRect(350, 440, 70, 21)) self.freq_dopasowane_label.setObjectName(_fromUtf8("freq_dopasowane_label")) self.przez_dopasowane_label = QtGui.QLabel(self.centralwidget) self.przez_dopasowane_label.setGeometry(QtCore.QRect(350, 460, 61, 21)) self.przez_dopasowane_label.setObjectName(_fromUtf8("przez_dopasowane_label")) self.chi_label = QtGui.QLabel(self.centralwidget) self.chi_label.setGeometry(QtCore.QRect(610, 420, 61, 21)) self.chi_label.setObjectName(_fromUtf8("chi_label")) self.amp_value = QtGui.QLabel(self.centralwidget) self.amp_value.setGeometry(QtCore.QRect(470, 420, 111, 21)) self.amp_value.setObjectName(_fromUtf8("amp_value")) self.freq_value = QtGui.QLabel(self.centralwidget) self.freq_value.setGeometry(QtCore.QRect(470, 440, 111, 21)) self.freq_value.setObjectName(_fromUtf8("freq_value")) self.przes_value = QtGui.QLabel(self.centralwidget) self.przes_value.setGeometry(QtCore.QRect(470, 460, 111, 21)) self.przes_value.setObjectName(_fromUtf8("przes_value")) self.chi_value = QtGui.QLabel(self.centralwidget) self.chi_value.setGeometry(QtCore.QRect(690, 420, 101, 21)) self.chi_value.setObjectName(_fromUtf8("chi_value")) MainWindow.setCentralWidget(self.centralwidget) self.statusbar = QtGui.QStatusBar(MainWindow) self.statusbar.setObjectName(_fromUtf8("statusbar")) MainWindow.setStatusBar(self.statusbar) self.spinbox_amp.setMaximum(10) self.spinbox_amp.setMinimum(0.1) self.spinbox_freq.setMaximum(10) self.spinbox_ilePkt.setMaximum(10000) self.spinbox_ilePkt.setMinimum(100) self.spinbox_przesuniecie.setMinimum(1) self.spinbox_przesuniecie.setMaximum(10) self.rysuj_button.clicked.connect(self.start) self.initSpinBox() self.retranslateUi(MainWindow) self.tabWidget.setCurrentIndex(0) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): MainWindow.setWindowTitle(_translate("MainWindow", "Fitter", None)) self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab), _translate("MainWindow", "Wykres", None)) self.iloscPkt_label.setText(_translate("MainWindow", "Ilosc punktow", None)) self.rozrzutPkt_label.setText(_translate("MainWindow", "Rozrzut punktow", None)) self.zakresOd_label.setText(_translate("MainWindow", "Zakres x od", None)) self.zakresDo_label.setText(_translate("MainWindow", "do", None)) self.rozklad_label.setText(_translate("MainWindow", "<b>Rozklad punktow:</b>", None)) self.funkcja_label.setText(_translate("MainWindow", "<b>Funkcja: sinus</b>", None)) self.amplituda_label.setText(_translate("MainWindow", "Amplituda:", None)) self.czestotliwosc_label.setText(_translate("MainWindow", "Czestotliwosc:", None)) self.przesuniecie_label.setText(_translate("MainWindow", "Przesuniecie:", None)) self.checkBox_poczatkowa.setText(_translate("MainWindow", "Funkcja poczatkowa", None)) self.checkBox_dopasowana.setText(_translate("MainWindow", "Funkcja dopasowana", None)) self.checkBox_dane.setText(_translate("MainWindow", "Dane", None)) self.rysuj_label.setText(_translate("MainWindow", "<b>Rysuj na wykresie:</b>", None)) self.rysuj_button.setText(_translate("MainWindow", "Rysuj", None)) self.dopasowane_label.setText(_translate("MainWindow", "<b>Dopasowane dane:</b>", None)) self.amp_dopasowane_label.setText(_translate("MainWindow", "Amplituda:", None)) self.freq_dopasowane_label.setText(_translate("MainWindow", "Czestotliwosc:", None)) self.przez_dopasowane_label.setText(_translate("MainWindow", "Przesuniecie:", None)) self.chi_label.setText(_translate("MainWindow", "Chi square:", None)) self.amp_value.setText(_translate("MainWindow", "x", None)) self.freq_value.setText(_translate("MainWindow", "x", None)) self.przes_value.setText(_translate("MainWindow", "x", None)) self.chi_value.setText(_translate("MainWindow", "x", None))
cnx.close() return _cities def population_of_region(self, region_polygon): population = 100 # offset for city in self.cities: if city.geom.within(region_polygon): population += city.population return population @staticmethod def estimate_load(population): # German per head power consumption in kWh according to statista (for the year 2015) per_head_power_consumption = 7.381 load_per_head = (per_head_power_consumption * 1000) / (365 * 24) total_load = population * load_per_head return total_load if __name__ == "__main__": bpoly = "POLYGON((7.5117 49.7913, 10.4956 49.7913, 10.4956 47.5325, 7.5117 47.5325, 7.5117 49.7913))" # bpoly = "POLYGON((5.87 55.1, 15.04 55.1, 15.04 47.27, 5.87 47.27, 5.87 55.1))" bayern_bounding_polygon = wkt.loads(bpoly) load_estimator = LoadEstimator(dict(), bayern_bounding_polygon) cities = load_estimator.cities interpolation_fct = load_estimator.interpolation_fct root = logging.getLogger() root.info('Plot inferred transmission system topology') plotter = Plotter('') plotter.plot_topology([], bayern_bounding_polygon, None, cities, interpolation_fct)
second_team.createTeamFromListOfDicts(second_team_config) third_team.createTeamFromListOfDicts(third_team_config) opposing_team_list = [first_team, second_team, third_team] pg = PokeGA(opposing_team_list) experiment_dir = 'Experiment-' + datetime.datetime.now().strftime("%m-%d-%Y_%H:%M:%S") os.mkdir(experiment_dir) results_file = open(experiment_dir + '/Experiment_Run_Results.txt', 'w') overall_time_start = time.time() if pg.draw_graph: plotter = Plotter() for experiment_num in range(1, 2): experiment_start = time.time() results_file.write("\n\nExperiment Number %d\n%s\n" % (experiment_num, '-'*20)) fittest_team = None for i in range(1, 31): print("Iteration: %d" % (i)) results_file.write("Iteration: %d\n" % (i)) if fittest_team is not None: this_fittest = pg.runAlgorithm(copy.deepcopy(fittest_team)) else: this_fittest = pg.runAlgorithm()
rovioEvaluator.alignMode = 1 rovioEvaluator.plotLeutiDistances = [] rovioEvaluator.initTimedData(td_rovio) rovioEvaluator.initTimedDataGT(td_vicon) rovioEvaluator.acquireData() rovioEvaluator.acquireDataGT() rovioEvaluator.getAllDerivatives() rovioEvaluator.alignTime() rovioEvaluator.alignBodyFrame() rovioEvaluator.alignInertialFrame() rovioEvaluator.getYpr() rovioEvaluator.evaluateSigmaBounds() if plotPos: # Position plotting plotterPos = Plotter(-1, [3,1],'Position',['','','time[s]'],['x[m]','y[m]','z[m]'],10000) if rovioEvaluator.doCov: plotterPos.addDataToSubplotMultiple(td_rovio, 'posSm', [1,2,3], ['r--','r--','r--'], ['','','']) plotterPos.addDataToSubplotMultiple(td_rovio, 'posSp', [1,2,3], ['r--','r--','r--'], ['','','']) plotterPos.addDataToSubplotMultiple(td_rovio, 'pos', [1,2,3], ['r','r','r'], ['','','']) plotterPos.addDataToSubplotMultiple(td_vicon, 'pos', [1,2,3], ['b','b','b'], ['','','']) if plotVel: # Velocity plotting plotterVel = Plotter(-1, [3,1],'Robocentric Velocity',['','','time[s]'],['$v_x$[m/s]','$v_y$[m/s]','$v_z$[m/s]'],10000) plotterVel.addDataToSubplotMultiple(td_rovio, 'vel', [1,2,3], ['r','r','r'], ['','','']) plotterVel.addDataToSubplotMultiple(td_vicon, 'vel', [1,2,3], ['b','b','b'], ['','','']) if plotAtt: # Attitude plotting plotterAtt = Plotter(-1, [4,1],'Attitude Quaternion',['','','','time[s]'],['w[1]','x[1]','y[1]','z[1]'],10000) plotterAtt.addDataToSubplotMultiple(td_rovio, 'att', [1,2,3,4], ['r','r','r','r'], ['','','','']) plotterAtt.addDataToSubplotMultiple(td_vicon, 'att', [1,2,3,4], ['b','b','b','b'], ['','','',''])
0, 1.0/(2**0.5) ] d = [ +1, -1, +1, -1, +1, -1, +1, -1 ] e = [ +1, +1, +1, +1, -1, -1, -1, -1 ] N = 8 for i in [(a, 'a'), (b, 'b'), (c, 'c'), (d, 'd'), (e, 'e')]: func = i[0] name = i[1] Plotter.plotRealAndImaginary( DFT.dft(func, N), N, "problem 2: part "+name) Plotter.show()
def __init__(self, destination): Plotter.__init__(self, destination)