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()
