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)
