def test_plot_not_exist_data(self): gpx = self.setUp(1) points = gpx.track.track_segment plot = Plotter(points) result = plot.setup() self.assertFalse(result)
def getPlotter(): global myPlotter if myPlotter is None: config = Config().getConfig() myPlotter = Plotter(config, 100, 70) myPlotter.init(False) return myPlotter
def plot_graph(self, index): gpx = self.get_gpx(index) points = gpx.track.track_segment plot = Plotter(points) result = plot.setup() if result: plot.plot() else: self.show_warning("Нехватает данных о высоте!")
def __init__(self, config, data_loader): self.generator = None self.discriminator = None self.g_optimizer = None self.d_optimizer = None self.g_conv_dim = config.g_conv_dim self.d_conv_dim = config.d_conv_dim self.z_dim = config.z_dim self.beta1 = config.beta1 self.beta2 = config.beta2 self.image_size = config.image_size self.data_loader = data_loader self.num_epochs = config.num_epochs self.batch_size = config.batch_size self.sample_size = config.sample_size self.lr = config.lr self.log_step = config.log_step self.sample_step = config.sample_step self.sample_path = config.sample_path self.model_path = config.model_path self.epoch = config.epoch self.build_model() self.plotter = Plotter()
def doMove(self, data): fromX = int(data['fromX']) fromY = int(data['fromY']) toX = int(data['toX']) toY = int(data['toY']) p = int(data['pen']) pen = PenDirection.Down if p == 0 else PenDirection.Up logger.info("Starting to Move to {},{} from {},{}".format( toX, toY, fromX, fromY)) config = Config().getConfig() plotter = Plotter(config, fromX, fromY) plotter.init(False) plotter.enableSteppers() plotter.moveTo(toX, toY, pen) plotter.disableSteppers() self.isPlottingInProgress = False logger.info("Done Stepping") return {'atX': toX, 'atY': toY}
def __init__(self, image_size=128, conv_dim=16): self.plotter = Plotter() self.iter = 0 super(Discriminator, self).__init__() # self.conv1 = conv() self.conv1 = nn.Sequential( conv(3, conv_dim, 4, bn=False)) # , conv(conv_dim, conv_dim * 2, 1, stride=1, pad=0)) # self.conv2 = nn.Sequential(conv(conv_dim*2, conv_dim*2, 4, bn=False), conv(conv_dim * 2, conv_dim * 4, 1, stride=1, pad=0)) # self.conv3 = nn.Sequential(conv(conv_dim*4, conv_dim*4, 4, bn=False), conv(conv_dim * 4, conv_dim * 8, 1, stride=1, pad=0)) # self.conv4 = nn.Sequential(conv(conv_dim*8, conv_dim*8, 4, bn=False), conv(conv_dim * 8, conv_dim * 16, 1, stride=1, pad=0)) # self.conv5 = nn.Sequential(conv(conv_dim*16, conv_dim*16, 4, bn=False), conv(conv_dim * 16, conv_dim * 32, 1, stride=1, pad=0)) self.conv2 = conv(conv_dim, conv_dim * 2, 4) self.conv3 = conv(conv_dim * 2, conv_dim * 4, 4) self.conv4 = conv(conv_dim * 4, conv_dim * 8, 4) self.conv5 = conv(conv_dim * 8, conv_dim * 16, 4) # self.fc = conv(conv_dim * 16, 1, conv_dim * 16, 1, 0, False) self.fc1 = nn.Linear(conv_dim * 16 * 4 * 2, 32) # self.fc1 = nn.Linear(4608, 1) self.fc2 = nn.Linear(32, 1)
Atom("C", array([0.0, 2 * a, 0.0])), ] four_atoms_cell = deepcopy(system.atoms) shift_r = array([0.0, 3.0 * a, 0.0]) for i in range(1, n): for atom in four_atoms_cell: new_atom = deepcopy(atom) new_atom.r = new_atom.r + i * shift_r system.atoms.append(new_atom) system.spin_multiplier = 1 system.k_points = [array([-pi / sqrt(3) / a, 0.0, 0.0]), array([0.0, 0.0, 0.0]), array([pi / sqrt(3) / a, 0, 0])] system.make_k_mesh(150) system.parameters = { "C": {"ep": 1.2057, "ed": 24.1657, "lambda": 0.001}, "CC": {"Vppp": -3.26, "Vpps": 0.0, "Vpds": 0.0, "Vpdp": 2.4, "Vdds": 0.0, "Vddp": 3.6, "Vddd": -7.4}, } for i in xrange(len(system.atoms)): system.atoms[i].orbitals = ["pz"] # ,'dxy', 'dyz', 'dxz', 'dx2-y2', 'dz2'] system.just_do_main_magic() lst = system.find_indeces_for_ldos(atom_idx=0) print lst plt = Plotter(system.name) plt.plot_energy_bands_from_file() doser = LDOSCalculator(1, system.name, 200, 0, indeces_list=lst) doser.f()
class Solver(object): def __init__(self, config, data_loader): self.generator = None self.discriminator = None self.g_optimizer = None self.d_optimizer = None self.g_conv_dim = config.g_conv_dim self.d_conv_dim = config.d_conv_dim self.z_dim = config.z_dim self.beta1 = config.beta1 self.beta2 = config.beta2 self.image_size = config.image_size self.data_loader = data_loader self.num_epochs = config.num_epochs self.batch_size = config.batch_size self.sample_size = config.sample_size self.lr = config.lr self.log_step = config.log_step self.sample_step = config.sample_step self.sample_path = config.sample_path self.model_path = config.model_path self.epoch = config.epoch self.build_model() self.plotter = Plotter() def build_model(self): """Build generator and discriminator.""" self.generator = Generator(z_dim=self.z_dim) print(count_parameters(self.generator)) self.discriminator = Discriminator() print(count_parameters(self.discriminator)) self.g_optimizer = optim.Adam(self.generator.parameters(), self.lr, (self.beta1, self.beta2)) self.d_optimizer = optim.Adam(self.discriminator.parameters(), self.lr*1, (self.beta1, self.beta2)) if self.epoch: g_path = os.path.join(self.model_path, 'generator-%d.pkl' % self.epoch) d_path = os.path.join(self.model_path, 'discriminator-%d.pkl' % self.epoch) g_optim_path = os.path.join(self.model_path, 'gen-optim-%d.pkl' % self.epoch) d_optim_path = os.path.join(self.model_path, 'dis-optim-%d.pkl' % self.epoch) self.generator.load_state_dict(torch.load(g_path)) self.discriminator.load_state_dict(torch.load(d_path)) self.g_optimizer.load_state_dict(torch.load(g_optim_path)) self.d_optimizer.load_state_dict(torch.load(d_optim_path)) if torch.cuda.is_available(): self.generator.cuda() self.discriminator.cuda() def to_variable(self, x): """Convert tensor to variable.""" if torch.cuda.is_available(): x = x.cuda() return Variable(x) def to_data(self, x): """Convert variable to tensor.""" if torch.cuda.is_available(): x = x.cpu() return x.data def reset_grad(self): """Zero the gradient buffers.""" self.discriminator.zero_grad() self.generator.zero_grad() def denorm(self, x): """Convert range (-1, 1) to (0, 1)""" out = (x + 1) / 2 return out.clamp(0, 1) def train(self): """Train generator and discriminator.""" fixed_noise = self.to_variable(torch.randn(self.batch_size, self.z_dim)) total_step = len(self.data_loader) for epoch in range(self.epoch, self.epoch + self.num_epochs) if self.epoch else range(self.num_epochs): for i, images in enumerate(self.data_loader): if len(images) != self.batch_size: continue # self.plotter.draw_kernels(self.discriminator) for p in self.discriminator.parameters(): p.requires_grad = True #===================== Train D =====================# images = self.to_variable(images) images.retain_grad() batch_size = images.size(0) noise = self.to_variable(torch.randn(batch_size, self.z_dim)) # Train D to recognize real images as real. outputs = self.discriminator(images) real_loss = torch.mean((outputs - 1) ** 2) # L2 loss instead of Binary cross entropy loss (this is optional for stable training) # real_loss = torch.mean(outputs - 1) # Train D to recognize fake images as fake. fake_images = self.generator(noise) fake_images.retain_grad() outputs = self.discriminator(fake_images) fake_loss = torch.mean(outputs ** 2) # fake_loss = torch.mean(outputs) # gradient penalty gp_loss = calc_gradient_penalty(self.discriminator, images, fake_images) # Backprop + optimize d_loss = fake_loss + real_loss + gp_loss self.reset_grad() d_loss.backward() self.d_optimizer.step() if i % 10 == 0: self.plotter.draw_activations(fake_images.grad[0], original=fake_images[0]) g_losses = [] for p in self.discriminator.parameters(): p.requires_grad = False #===================== Train G =====================# for g_batch in range(5): noise = self.to_variable(torch.randn(batch_size, self.z_dim)) # Train G so that D recognizes G(z) as real. fake_images = self.generator(noise) outputs = self.discriminator(fake_images) g_loss = torch.mean((outputs - 1) ** 2) # g_loss = -torch.mean(outputs) # Backprop + optimize self.reset_grad() g_loss.backward() # if g_loss.item() < 0.5 * d_loss.item(): # break self.g_optimizer.step() g_losses.append("%.3f"%g_loss.clone().item()) # print the log info if (i+1) % self.log_step == 0: print('Epoch [%d/%d], Step[%d/%d], d_real_loss: %.4f, ' 'd_fake_loss: %.4f, gp_loss: %s, g_loss: %s' %(epoch+1, self.num_epochs, i+1, total_step, real_loss.item(), fake_loss.item(), gp_loss.item(), ", ".join(g_losses))) # save the sampled images # print((i+1)%self.sample_step) if (i) % self.sample_step == 0: print("saving samples") fake_images = self.generator(fixed_noise) if not os.path.exists(self.sample_path): os.makedirs(self.sample_path) torchvision.utils.save_image(self.denorm(fake_images.data), os.path.join(self.sample_path, 'fake_samples-%d-%d.png' %(epoch+1, i+1))) # save the model parameters for each epoch if epoch % 5 == 0: if not os.path.exists(self.model_path): os.mkdir(self.model_path) g_path = os.path.join(self.model_path, 'generator-%d.pkl' %(epoch+1)) d_path = os.path.join(self.model_path, 'discriminator-%d.pkl' %(epoch+1)) g_optim_path = os.path.join(self.model_path, 'gen-optim-%d.pkl' % (epoch + 1)) d_optim_path = os.path.join(self.model_path, 'dis-optim-%d.pkl' % (epoch + 1)) torch.save(self.generator.state_dict(), g_path) torch.save(self.discriminator.state_dict(), d_path) torch.save(self.g_optimizer.state_dict(), g_optim_path) torch.save(self.d_optimizer.state_dict(), d_optim_path) def sample(self): # Load trained parameters g_path = os.path.join(self.model_path, 'generator-%d.pkl' % self.num_epochs) d_path = os.path.join(self.model_path, 'discriminator-%d.pkl' % self.num_epochs) self.generator.load_state_dict(torch.load(g_path)) self.discriminator.load_state_dict(torch.load(d_path)) self.generator.eval() self.discriminator.eval() # Sample the images noise = self.to_variable(torch.randn(self.sample_size, self.z_dim)) fake_images = self.generator(noise) sample_path = os.path.join(self.sample_path, 'fake_samples-final.png') torchvision.utils.save_image(self.denorm(fake_images.data), sample_path, nrow=12) print("Saved sampled images to '%s'" %sample_path)
'CC': { 'Vsss': - 6.7, 'Vsps': 5.5, 'Vpps': 5.1, 'Vppp': -3.1, } } system.s_parameters = { 'C': { 'es': 1., 'ep': 1., 'lambda': 0., }, 'CC': { 'Vsss': 0.2, 'Vsps': - 0.1, 'Vpps': - 0.15, 'Vppp': 0.12, } } for i in xrange(len(system.atoms)): system.atoms[i].orbitals = ['s', 'px', 'py', 'pz', ] system.just_do_main_magic() plotter = Plotter(system.name) plotter.plot_energy_bands_from_file()
def task1(original_signal: Signal, original_freq, carrier_freq, global_pref=None, k=64, noise_freq=None): Plotter.plot(original_signal, _title_pref=global_pref) Plotter.fourier_transform(original_signal, _title_pref=global_pref) modulated_signal = DoubleSideband(original_signal, carrier_freq) if noise_freq is not None: modulated_signal = modulated_signal + Sine(noise_freq, amplitude=amplitude, t_start=0, t_end=1, discretization=10000) Plotter.plot(modulated_signal, t_end=0.1, _title_pref=global_pref) Plotter.fourier_transform(modulated_signal, _title_pref=global_pref) signal_fft = abs(fftshift(fft(modulated_signal.get_y()))) signal_fft = 2 * signal_fft / len(signal_fft) f_fft = fftshift( fftfreq(len(modulated_signal.get_x()), abs(modulated_signal.get_x()[1] - modulated_signal.get_x()[0]))) if noise_freq is None: print( find_freqs(signal_fft[len(signal_fft) // 2 - 1:], f_fft[len(f_fft) // 2 - 1:], 3)) else: print( find_freqs(signal_fft[len(signal_fft) // 2 - 1:], f_fft[len(f_fft) // 2 - 1:], 4)) discrete_signal = Discrete(modulated_signal, k, signal_min=min(modulated_signal.get_y()), signal_max=max(modulated_signal.get_y())) Plotter.plot(discrete_signal, t_end=0.1, _title_pref=global_pref) detected_signal = Detect(discrete_signal, carrier_freq, filter_freq=30) Plotter.plot(detected_signal, t_end=0.1, _title_pref=global_pref) Plotter.fourier_transform(detected_signal, _title_pref=global_pref) signal_fft = abs(fftshift(fft(detected_signal.get_y()))) signal_fft = 2 * signal_fft / len(signal_fft) f_fft = fftshift( fftfreq(len(detected_signal.get_x()), abs(detected_signal.get_x()[1] - detected_signal.get_x()[0]))) print( find_freqs(signal_fft[len(signal_fft) // 2 - 1:], f_fft[len(f_fft) // 2 - 1:], 2)) detected_signal2 = Detect(detected_signal, original_freq, filter_freq=7) Plotter.plot(detected_signal2, _title_pref=global_pref) Plotter.fourier_transform(detected_signal2, _title_pref=global_pref) lbound = max(detected_signal2.get_y()) / pow(10, 3 / 20) print("lbound: %d" % lbound) sig_out = np.ones(len(detected_signal2.get_x())) for i in range(0, len(detected_signal2.get_x())): if detected_signal2.get_y()[i] <= lbound: sig_out[i] = 0 else: break k = 1 while sig_out[k] == 0: k = k + 1 if k == sig_out.__len__() - 1: break print('delay: %f' % detected_signal2.get_x()[k]) pyplot.plot(detected_signal.get_x(), sig_out, '.') # pyplot.xlim(0, 1000) pyplot.show()
unlabelled_data_store = DataStore( unlabelled_options.identity, data_set_csv_path=unlabelled_options.data_path, data_set_output_dir=labelled_options.output_dir, data_groups=unlabelled_options.groups, select_columns=unlabelled_options.cols, shuffle=unlabelled_options.shuffle, random_state=unlabelled_options.random_state, persist=unlabelled_options.persist) # Get the three split sets of data as configured with labelled_options.groups training_data = labelled_data_store.get_data('train') testing_data = labelled_data_store.get_data('test') verification_data = labelled_data_store.get_data('ver') print(training_data) # Create an example plot using training data labelled_plotter = Plotter(labelled_options.identity, labelled_options.plot_path) labelled_plotter.display_plot(0, 'Survived vs Passenger ID', True, training_data['PassengerId'], AxisOptions('Passenger ID'), training_data['Survived'], AxisOptions('Survived'), style='g.', size=[7.2, 5.76], legend=False)
class Recorder(QMainWindow): '''Main Window - menu toolbar to load and save session, open plotter and set server - dock widget holding session and run information - grid plot to stream current emg data of 16 channels - start, stop, progressbar and trigger for current run ''' def __init__(self, parent=None): super(Recorder, self).__init__(parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.plotter = None self.session = None self.server = DelsysStation(parent=self) self.ui.dockWidget.setWidget(QWidget()) self.dockLayout = QGridLayout(self.ui.dockWidget.widget()) self.showSessionMeta = None self.showRunMeta = None self.plotWidget = None self.plots = [] self.startTime = datetime.now() self.pinger = QTimer(self) # timer to read data from server whenever available self.runPinger = QTimer(self) # timer to call stop when run duration times out self.runPinger.setSingleShot(True) self.runPinger.timeout.connect(self.stop) self.pinger.timeout.connect(self.ping) self.kinectRecorder=None self.newpath=None self.notSavedState = False def clearDock(self): ''' clear session (dock widget elements) - remove showSessionMeta - remove showRunMeta - kill kinectRecorder - remove session if changes are not saved, ask ''' if self.showSessionMeta is not None: reply = QMessageBox.question(self, 'QMessageBox.question()', 'Do you want to first save the current session?', QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel) if reply == QMessageBox.Yes: self.save() elif reply == QMessageBox.Cancel: return self.session = None self.dockLayout.removeWidget(self.showSessionMeta) self.dockLayout.removeWidget(self.showRunMeta) self.showSessionMeta.deleteLater() self.showRunMeta.deleteLater() self.showSessionMeta = None self.showRunMeta = None self.kinectRecorder.killRecorder() def preparePlots(self): '''arange 2x8 plots for each channel and set parameters ''' if self.ui.frame.layout() is None: layout = QGridLayout() self.ui.frame.setLayout(layout) else: ######### # reset # ######### layout = self.ui.frame.layout() layout.removeWidget(self.plotWidget) self.plotWidget = None self.plots = [] self.plotWidget = pg.GraphicsLayoutWidget(border=(100,100,100)) layout.addWidget(self.plotWidget) for i in range(8): for k in range(2): self.plots.append(self.plotWidget.addPlot(title="EMG " + str(k+2*i+1))) self.plots[-1].plot(np.linspace(0,2,1000)) self.plots[-1].setYRange(-0.0002, 0.0002) self.plotWidget.nextRow() self.plotWidget.show() def setServer(self): ''' open dialog to set server address e.g. localhost, 192.168.1.5 ''' text, ok = QInputDialog.getText(self, "Set server", 'Enter server adress') if ok: self.server.host = text def newSession(self): ''' create new session: - clear dock - open dialog to set session parameters - create showSessionMeta, showRunMeta, kinectRecorder ''' self.clearDock() sessionDialog = SessionDialog(self) if sessionDialog.exec_(): newpath = os.path.join(sessionDialog.ui.leDir.text(), sessionDialog.ui.leName.text()) if not os.path.isdir(newpath): os.makedirs(newpath) else: print('reusing folder') QMessageBox.information(self, 'Warning!', '''You\'re reusing the subject folder''', QMessageBox.Ok) self.session = Session(sessionDialog.ui.leName.text(), sessionDialog.ui.teBemerkung.toPlainText(), newpath) self.showSessionMeta = sessionView(self.session, self) self.showRunMeta = RunWidget(self) self.showRunMeta.ui.leCurrentRun.setText(str(len(self.session.runs))) try: self.kinectRecorder=KinectRecorder() except: print "no Kinect recording" self.kinectRecorder = None self.showSessionMeta.ui.showBemerkung.textChanged.connect(self.pendingSave) self.showRunMeta.ui.lwRuns.itemDoubleClicked.connect(self.openPlotter) self.dockLayout.addWidget(self.showSessionMeta) self.dockLayout.addWidget(self.showRunMeta) self.showRunMeta.show() self.showSessionMeta.show() self.preparePlots() self.ui.tbStart.setEnabled(True) def pendingSave(self): self.notSavedState = True self.setWindowTitle("PyTrigno(*)") def save(self): self.notSavedState = False self.setWindowTitle("PyTrigno") self.session.remarks = self.showSessionMeta.ui.showBemerkung.toPlainText() self.session.dump("ReadMe.txt") def startRun(self): ''' start a recording: - setup server - setup timer (if no eternity is toggled) - setup progress bar - setup buttons - setup session - start recorder ''' #setup server self.server.exitFlag = False try: self.startTime = datetime.now() self.server.start() except: print("something went wrong") self.server.exitFlag = True raise socket.timeout("Could not connect to Delsys Station") else: if self.showRunMeta.ui.cbEternity.checkState() == 0: duration = self.showRunMeta.ui.timeEdit.time() d = duration.second() + duration.minute()*60 self.runPinger.start(d*1000) self.ui.elapsedTime.setRange(0,d) elif self.showRunMeta.ui.cbEternity.checkState() == 2: self.ui.elapsedTime.setRange(0,0) self.pinger.start() self.ui.tbStop.setEnabled(True) self.ui.tbTrigger.setEnabled(True) self.ui.tbStart.setEnabled(False) name = self.showRunMeta.ui.leCurrentRun.text() self.session.addRun(name) if self.kinectRecorder is not None: self.kinectRecorder.startRecording(self.newpath+'\\'+name+'.oni') self.ui.elapsedTime.setRange(0,d) def stop(self): ''' stop recording due to button press or timeout - setup buttons - stop timers - stop server - kill kinectRecorder - add item to list of runs ''' self.ui.tbStop.setEnabled(False) self.ui.tbTrigger.setEnabled(False) self.ui.tbStart.setEnabled(True) self.ui.elapsedTime.reset() QListWidgetItem(self.showRunMeta.ui.leCurrentRun.text(), self.showRunMeta.ui.lwRuns) self.showRunMeta.ui.leCurrentRun.setText(str(len(self.session.runs))) self.server.exitFlag = True self.server.stop() self.runPinger.stop() self.pinger.stop() self.session.stopRun(self.server.buffer) self.server.buffer = None if self.kinectRecorder is not None: self.kinectRecorder.stopRecording() self.server.flush() def trigger(self): ''' add a trigger ''' print("trigger") trigger = self.server.buffer[0].shape[1] self.session.addTrigger(trigger) def ping(self): ''' update progress bar and plots everytime new data is available ''' elapsed = int((datetime.now()-self.startTime).total_seconds()) self.ui.elapsedTime.setValue(elapsed) for p in range(len(self.plots)): if self.server.buffer[0].shape[1] < 5000: self.plots[p].plot(self.server.buffer[0][p], clear=True) else: self.plots[p].plot(self.server.buffer[0][p,-5000:], clear=True) def openPlotter(self, item=None): if self.plotter is None: self.plotter = Plotter() if item is not None: self.plotter.load([os.path.join(self.session.dir, item.text()) + ".pk"]) self.plotter.show() def closeEvent(self, event): if self.notSavedState: reply = QMessageBox.question(self, 'QMessageBox.question()', 'Do you want to first save the current session?', QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel) else: reply = QMessageBox.No if reply == QMessageBox.Yes: self.save() elif reply == QMessageBox.Cancel: event.ignore() return if not self.server.exitFlag: self.stop() event.accept()
win_length = n_fft sr = 44100 y, sr = librosa.load(audio_filename, sr=sr) bpm = int(round(SoundProcessor.get_bpm(y, sr))) # bpm = 130.5 track_duration = SoundProcessor.get_duration(y, sr) fft_frequencies = SoundProcessor.generate_fft_frequencies(sr, n_fft) decibel_matrix = SoundProcessor.detect_pitch_stft(y, n_fft, hop_length) frames_number = SoundProcessor.get_frames_number(decibel_matrix) frame_duration = SoundProcessor.get_frame_duration(track_duration, frames_number) beats_frame_duration = SoundProcessor.seconds_to_beats(bpm, frame_duration) extracted_frequencies, extracted_frequencies_decibel_matrix = SoundProcessor.extract_frequencies(frames_number, decibel_matrix, fft_frequencies) extracted_midis = SoundProcessor.hz_to_midi(extracted_frequencies) Plotter.spectrogram_plot(decibel_matrix, y, sr, hop_length, 'track_spectrogram.png') Plotter.spectrogram_plot(extracted_frequencies_decibel_matrix, y, sr, hop_length, 'extracted_frequencies_spectrogram.png') notes_with_duration = UltrastarMapGenerator.get_duration_with_note(extracted_midis, beats_frame_duration) notes_with_duration, gap_in_beats = UltrastarMapGenerator.get_gap(notes_with_duration) gap = SoundProcessor.seconds_to_ms(SoundProcessor.beats_to_seconds(bpm, gap_in_beats)) # filtered_notes_with_duration = SoundProcessor.filter_computational_errors(notes_with_duration, min_beat_number) notes_with_rounded_duration = UltrastarMapGenerator.round_beats(notes_with_duration) notes_with_duration_beat_and_beat_numbers = UltrastarMapGenerator.get_beat_numbers(notes_with_rounded_duration) MidiCreator.create_midi(notes_with_duration_beat_and_beat_numbers, bpm, frame_duration, output_midi_filename) ultrastar_notes_with_duration_beat_and_beat_numbers = UltrastarMapGenerator.midi_to_ultrastar_note(notes_with_duration_beat_and_beat_numbers) syllables = SyllableReader.get_syllables_from_file(syllables_filename) notes_with_duration_beat_numbers_and_syllables = UltrastarMapGenerator\
def doPlot(self, data): self.isPlottingInProgress = True self.progress.clear() logger.info("Starting to Plot") orgX = int(data['orgX']) orgY = int(data['orgY']) cords = data['cords'] config = Config().getConfig() plotter = Plotter(config, orgX, orgY) plotter.init(False) plotter.enableSteppers() minX = min(cords['x']) maxX = max(cords['x']) minY = min(cords['y']) maxY = max(cords['y']) ax = [] # additional coordinates ay = [] # additional coordinates ap = [] # move to origin, even if we are already there ax.append(orgX) ay.append(orgY) ap.append(0) # PenDirection.Up #plotter.moveTo(minX, minY, PenDirection.Up) ax.append(minX) ay.append(minY) ap.append(0) # PenDirection.Up # top left corner horizontal line #plotter.moveTo(minX+10, minY, PenDirection.Down) ax.append(minX + 10) ay.append(minY) ap.append(1) # PenDirection.Down #plotter.moveTo(maxX-10, minY, PenDirection.Up) ax.append(maxX - 10) ay.append(minY) ap.append(0) # PenDirection.up # top Right # top right corner horizontal line #plotter.moveTo(maxX, minY, PenDirection.Down) ax.append(maxX) ay.append(minY) ap.append(1) # top right corner vertical line #plotter.moveTo(maxX, minY+10, PenDirection.Down) ax.append(maxX) ay.append(minY + 10) ap.append(1) #plotter.moveTo(maxX, maxY-10, PenDirection.Up) ax.append(maxX) ay.append(maxY - 10) ap.append(0) # bottom Right # bottom right corner vertical line #plotter.moveTo(maxX, maxY, PenDirection.Down) ax.append(maxX) ay.append(maxY) ap.append(0) # bottom right corner horizontal line #plotter.moveTo(maxX-10, maxY, PenDirection.Down) ax.append(maxX - 10) ay.append(maxY) ap.append(1) #plotter.moveTo(minX+10, maxY, PenDirection.Up) ax.append(minX + 10) ay.append(maxY) ap.append(0) # bottom left # bottom left corner horizontal line #plotter.moveTo(minX, maxY, PenDirection.Down) ax.append(minX) ay.append(maxY) ap.append(1) # bottom left corner vertical line #plotter.moveTo(minX, maxY-10, PenDirection.Down) ax.append(minX) ay.append(maxY - 10) ap.append(1) ax.append(minX) ay.append(minY) ap.append(0) cords['x'] = ax + cords['x'] cords['y'] = ay + cords['y'] cords['p'] = ap + cords['p'] total = len(cords['x']) for index in range(0, total - 1): x = int(cords['x'][index]) y = int(cords['y'][index]) pen = PenDirection.Down if cords['p'][ index] == 0 else PenDirection.Up perComplete = round(index / total * 100, 2) self.progress.append((x, y, perComplete)) plotter.moveTo(x, y, pen) logger.debug("Plotting {}%%".format(perComplete)) plotter.finalize() self.progress.append((plotter.orgX, plotter.orgY, 100)) logger.info("Done Plotting") self.isPlottingInProgress = False return "Complete"
def doStep(self, data): dir = data['dir'] steps = int(data['steps']) self.isPlottingInProgress = True logger.info("Starting to Step") config = Config().getConfig() plotter = Plotter(config, 0, 0) plotter.init(False) plotter.enableSteppers() plotter.movePen(PenDirection.Up) if dir == "leftUp": plotter.moveLeft(CordDirection.Backward, steps) if dir == "leftDown": plotter.moveLeft(CordDirection.Forward, steps) if dir == "rightUp": plotter.moveRight(CordDirection.Backward, steps) if dir == "rightDown": plotter.moveRight(CordDirection.Forward, steps) plotter.disableSteppers() self.isPlottingInProgress = False logger.info("Done Stepping") return 'done'
# training = 'all_channels_200523_15h_3m' # training = 'all_channels_200523_15h_16m' plotter = Plotter (channel = ch, base_dir = '/Users/manzoni/Documents/HNL/ntuples/20may20', #env['NTUPLE_DIR'], post_fix = 'HNLTreeProducer_%s/tree.root' %ch, selection_data = selection, selection_mc = selection_mc, selection_tight = selection_tight, pandas_selection = pandas_selection, lumi = 59700., model = '/'.join([env['NN_DIR'], 'trainings', training, 'net_model_weighted.h5' ]), transformation = '/'.join([env['NN_DIR'], 'trainings', training, 'input_tranformation_weighted.pck']), features = '/'.join([env['NN_DIR'], 'trainings', training, 'input_features.pck' ]), process_signals = False, # switch off for control regions mini_signals = False, # process only the signals that you'll plot plot_signals = False, blinded = False, datacards = ['hnl_m_12_lxy_lt_0p5', 'hnl_m_12_lxy_0p5_to_1p5', 'hnl_m_12_lxy_1p5_to_4p0', 'hnl_m_12_lxy_mt_4p0'], # FIXME! improve this to accept wildcards / regex mc_subtraction = True, dir_suffix = 'check_alt_prompt_estimate', relaxed_mc_scaling = 0.05, ) if __name__ == '__main__': plotter.plot()
def openPlotter(self, item=None): if self.plotter is None: self.plotter = Plotter() if item is not None: self.plotter.load([os.path.join(self.session.dir, item.text()) + ".pk"]) self.plotter.show()