def StartTracking(self): print('Starting Tracker') self.ProcessDelay = QTimer() self.ProcessDelay.timeout.connect(self.ShowMousePosition) try: self.ProcessDelay.start(500) while self.ContinueProcessing: x, y = pyautogui.position() self.strPositn = '' self.strPositn += 'Mouse X: ' self.strPositn += str(x).rjust(4) self.strPositn += ' Mouse Y: ' self.strPositn += str(y).rjust(4) QCoreApplication.processEvents() time.sleep(0.750) if self.EndProcess: self.ProcessDelay.stop() self.ContinueProcessing = False except KeyboardInterrupt: print('Error Occurred Program Aborting')
def getSerialAck(self): string = "" succeeded = False self.serialState = SerialState.WaitingToStart currentSerialString = "" currentCheckSum = bytearray(2) while(self.serialTimeoutTimer.remainingTime()>0): QCoreApplication.processEvents() self.processCheckStopRequest() if self.serialState == SerialState.WaitingToStart: newByte = self.serialPort.read() if len(newByte) == 1: if newByte[0] == STARTING_BYTE: self.serialState = SerialState.WaitingForString if self.serialState == SerialState.WaitingForString: newBytes = self.serialPort.read_until(b'\0') if len(newBytes) >= 1: for i in range (len(newBytes)): if newBytes[i] == STARTING_BYTE: pass else: currentSerialString = currentSerialString + newBytes[i:].decode("utf-8") if newBytes[-1] == 0x00: self.serialState = SerialState.WaitingForChecksum1 break if self.serialState == SerialState.WaitingForChecksum1: newByte = self.serialPort.read() if len(newByte) == 1: currentCheckSum[0] = newByte[0] self.serialState = SerialState.WaitingForChecksum2 if self.serialState == SerialState.WaitingForChecksum2: newByte = self.serialPort.read() if len(newByte) == 1: currentCheckSum[1] = newByte[0] self.serialState = SerialState.CommandDone if self.serialState == SerialState.CommandDone: # check the message integrity receivedCommandCrc = Crc16() receivedCommandCrc.process(currentSerialString.encode('utf-8')) receivedCommandCrcBytes = receivedCommandCrc.finalbytes() # print("Checksum Calc based on {}".format(currentSerialString.encode('utf-8'))) # print("Checksum Received: {}, Calculated: {}".format(currentCheckSum, receivedCommandCrcBytes)) if receivedCommandCrcBytes == currentCheckSum: succeeded = True string = currentSerialString.split(":")[1].rstrip(' \t\r\n\0') if string == "None": string = "" else: self.log("Acknowledgment Failed, received: {}".format(currentSerialString.rstrip("\t\r\n\0")), type="ERROR") string = currentSerialString break return succeeded, string
def on_perform_clicked(self): if self.__dataset is None: self.show_error(self.tr("Dataset has not been loaded.")) return self.perform_button.setEnabled(False) self.perform_with_customized_ems_button.setEnabled(False) resolver = EMMAResolver() resolver_setting = self.neural_setting.setting results = [] n_members_list = self.n_members_list self.progress_bar.setRange(0, len(n_members_list)) self.progress_bar.setValue(0) self.progress_bar.setFormat(self.tr("Performing EMMA [%v/%m]")) QCoreApplication.processEvents() for i, n_members in enumerate(n_members_list): result = resolver.try_fit(self.__dataset, self.distribution_type, n_members, resolver_setting) results.append(result) self.progress_bar.setValue(i + 1) QCoreApplication.processEvents() self.add_results(results) self.progress_bar.setFormat(self.tr("Finished")) self.perform_button.setEnabled(True) self.perform_with_customized_ems_button.setEnabled(True) if len(results) > 1: self.emma_summary_chart.show_distances(results) self.emma_summary_chart.show()
def __init__(self, soundfile, parent): self.soundfile = soundfile self.isplaying = False self.time = 0 # current audio position in frames self.audio = QMediaPlayer() self.decoder = QAudioDecoder() self.is_loaded = False self.volume = 100 self.isplaying = False self.decoded_audio = {} self.only_samples = [] self.decoding_is_finished = False self.max_bits = 32768 self.signed = False # File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works self.audio.durationChanged.connect(self.on_durationChanged) self.decoder.finished.connect(self.decode_finished_signal) self.audio.setMedia(QUrl.fromLocalFile(soundfile)) self.decoder.setSourceFilename(soundfile) # strangely inconsistent file-handling # It will hang here forever if we don't process the events. while not self.is_loaded: QCoreApplication.processEvents() time.sleep(0.1) self.decode_audio() self.np_data = np.array(self.only_samples) if not self.signed: # don't ask me why this fixes 8 bit samples... self.np_data = self.np_data - self.max_bits / 2 print(len(self.only_samples)) print(self.max_bits) self.isvalid = True
def stop(self): """ Perform stop operation :return: None """ logger.internal("entering stop operation, old state %s", FilterState.state2str(self._state)) assertMainThread() while self._operationInProgress and self._state != FilterState.ACTIVE: QCoreApplication.processEvents() if self._state != FilterState.ACTIVE: logger.warning("Unexpected state %s", FilterState.state2str(self._state)) raise FilterStateMachineError(self._state, FilterState.STOPPING) self._operationInProgress = True self._state = FilterState.STOPPING for itc in self._interThreadConns: # set connections in active mode. itc.setStopped(True) self.performOperation.emit("stop", Barrier(len(self._threads))) while self._state == FilterState.STOPPING: logger.internal("stopping ... %s", FilterState.state2str(self._state)) QCoreApplication.processEvents() self._operationInProgress = False logger.internal("leaving stop operation, new state %s", FilterState.state2str(self._state))
async def KEAlive(self, finishedState): while finishedState.is_set(): QCoreApplication.processEvents() trio.sleep(0.1) return return
def waitForSignal(signal, callback=None, timeout=None): """ Waits for the given signal. If a callback is given, it will be called with the signal's arguments until the return value of the callback evaluates to true. If a timeout is given (in seconds), a TimeoutError will be thrown after the time has elapsed. :param signal: a Qt signal to be waited for, suitable for slot connections. :param callback: a callable called :param timeout: an optional timeout in seconds. :return: None """ _received = False _sigArgs = None def _slot(*args, **kw): nonlocal _received, _sigArgs _sigArgs = args if callback is None: _received = True else: if callback(*args, **kw): _received = True if not signal.connect(_slot, Qt.QueuedConnection): raise NexTInternalError("cannot connect the signal.") t0 = time.perf_counter() while not _received: QCoreApplication.processEvents() if timeout is not None and time.perf_counter() - t0 > timeout: signal.disconnect(_slot) raise TimeoutError() signal.disconnect(_slot) return _sigArgs
def compute_map(self): if self.map is None: start = time() self.map_button.setText( self.tr('Computing heatmap, please wait...')) modify_font(self.map_button, bold=False, italic=True) QCoreApplication.processEvents() mapp, valid, range0, range1, imgsize, other = noiseprint_blind_post( self.noise, self.image0) if mapp is None: QMessageBox.critical(self, self.tr('Error'), self.tr('Too many invalid blocks!')) return self.map = cv.applyColorMap( genMappUint8(mapp, valid, range0, range1, imgsize), cv.COLORMAP_JET) self.map_viewer.update_processed(self.map) elapsed = time() - start self.map_button.setText( self.tr('Heatmap computed ({:.1f} s)'.format(elapsed))) modify_font(self.map_button, bold=False, italic=False) self.map_button.setCheckable(True) self.map_button.setChecked(True) self.noise_viewer.viewChanged.connect(self.map_viewer.changeView) self.map_viewer.viewChanged.connect(self.noise_viewer.changeView)
def test_execute_forward_archives_output_files(self): with TemporaryDirectory() as temp_dir: script_dir = pathlib.Path(temp_dir, "scripts") script_dir.mkdir() script_file_name = self._write_output_script(script_dir) script_files = [script_file_name] output_files = ["out.dat", "subdir/out.txt"] app_settings = _MockSettings() logger = mock.MagicMock() tool_specification = PythonTool( "Python tool", "Python", str(script_dir), script_files, app_settings, None, logger, outputfiles=output_files, ) work_dir = pathlib.Path(temp_dir, "work") work_dir.mkdir() archive_dir = pathlib.Path(temp_dir, "archive") archive_dir.mkdir() executable = ExecutableItem("Create files", str(work_dir), str(archive_dir), tool_specification, [], logger) executable.execute([], ExecutionDirection.FORWARD) while executable._tool_instance is not None: QCoreApplication.processEvents() archives = list(archive_dir.iterdir()) self.assertEqual(len(archives), 1) self.assertNotEqual(archives[0].name, "failed") self.assertTrue(pathlib.Path(archives[0], "out.dat").exists()) self.assertTrue( pathlib.Path(archives[0], "subdir", "out.txt").exists())
def get_dirnames(app=None): from PySide2.QtCore import Qt, QCoreApplication from PySide2.QtWidgets import QApplication, QFileDialog, QTreeView, QListView, QAbstractItemView from pathlib import Path if not app: app = QApplication(sys.argv) # file_dialog = QFileDialog() # file_dialog.setWindowFlags(Qt.WindowStaysOnTopHint) # file_location = file_dialog.getOpenFileNames() file_dialog = QFileDialog() file_dialog.setFileMode(QFileDialog.DirectoryOnly) file_dialog.setOption(QFileDialog.DontUseNativeDialog, True) file_view = file_dialog.findChild(QListView, 'listView') # to make it possible to select multiple directories: if file_view: file_view.setSelectionMode(QAbstractItemView.MultiSelection) f_tree_view = file_dialog.findChild(QTreeView) if f_tree_view: f_tree_view.setSelectionMode(QAbstractItemView.MultiSelection) if file_dialog.exec(): paths = file_dialog.selectedFiles() QCoreApplication.processEvents() for path in paths: yield Path(path)
def async_run_await_result(function, *args, **kwargs): future_obj = thread_pool.submit(function, *args, **kwargs) while not future_obj.done(): QCoreApplication.processEvents() time.sleep(0.1) future_result = future_obj.result() return future_result
def _sendCommand(self, command, payload, timeout=SERIAL_COMMAND_TIMEOUT, max_retry=SERIAL_COMMAND_MAX_TRIALS): if not command in SERIAL_COMMANDS: print("The command provided {} is not a valid serial command".format(command)) return FAILURE_CODE sendBuffer = bytearray() sendBuffer.append(STARTING_BYTE) sendString = command + ":" + payload sendBuffer.extend(sendString.encode("utf-8")) sendBuffer.append(0x00) newChecksum = Crc16() # print("Checksum Calc based on {}".format(sendBuffer[1:])) newChecksum.process(sendBuffer[1:]) checksumBytes = newChecksum.finalbytes() sendBuffer.extend(checksumBytes) # print(len(sendBuffer)) for attempt in range(max_retry): if attempt != 0: self.log(f"Attempt #{attempt+1} to send the command {command} with payload {payload}", type="DEBUG") QCoreApplication.processEvents() # t = time.time() try: self.serialPort.flushInput() self.serialPort.write(sendBuffer) except SerialTimeoutException: self.serialPort.flushOutput() continue self.serialTimeoutTimer.setInterval(timeout) self.serialTimeoutTimer.start() succeeded, string = self.getSerialAck() # print("The time spent from sending a command to receiving a reply (or timeouting) is ",time.time()-t) if succeeded: return string elif not succeeded and "EXCEPTION" in string: break return FAILURE_CODE
def save_callback(i, n): if progress.wasCanceled(): nonlocal canceled canceled = True raise StopIteration() progress.setValue((i+1)/n*100) QCoreApplication.processEvents()
def updateStatus(self, status, isError=False): newLine = QLabel(('ERROR' if isError else 'STATUS') + f': {status}') newLine.setWordWrap(True) self.statusText.addWidget(newLine) self.statusWidget.setLayout(self.statusText) QCoreApplication.processEvents() QCoreApplication.processEvents() self.statusTextScroll.verticalScrollBar().setValue(self.statusTextScroll.verticalScrollBar().maximum() + 1)
def rerender_wppf(self): HexrdConfig().wppf_data = list(self.wppf_object.spectrum_sim.data) HexrdConfig().rerender_wppf.emit() # Process events to make sure it visually updates. # If this causes issues, we can post self.wppf_object.RefineCycle() # calls to the event loop in the future instead. QCoreApplication.processEvents()
async def pullOutput(self, proc): x = await proc.stdout.receive_some() x = x.decode() result = '' while (x != ''): QCoreApplication.processEvents() result = result + x x = await proc.stdout.receive_some() x = x.decode() return result
def on_shotgun_export(self, sg_password: str): """on_shotgun_export will export a the latest sequence revision to shotgun. Will first retrieve all the media info per shots from flix_ui, and will start creating or reusing projects / sequence / shots and version per shot from shotgun_ui, It will then export a quicktime per shot from flix_ui and will upload it to shotgun Arguments: sg_password {str} -- Shotgun password """ if self.wg_flix_ui.is_authenticated() is False: self.__error('you need to be authenticated to Flix') return self.__init_progress(2) try: self.__update_progress('get media object per shots', False) mo_per_shots = self.wg_flix_ui.get_media_object_per_shots( self.__update_progress) if mo_per_shots is None: return self.progress.setRange(0, 2 + len(mo_per_shots) * 2) self.progress.repaint() QCoreApplication.processEvents() _, _, show_tc = self.wg_flix_ui.get_selected_show() _, seq_rev_nbr, seq_tc = self.wg_flix_ui.get_selected_sequence() # Create project / sequence / shot and version in Shotgun self.__update_progress('push to shotgun', False) shot_to_file = self.wg_shotgun_ui.export_to_version( mo_per_shots.keys(), sg_password, show_tc, seq_rev_nbr, seq_tc, self.__update_progress) temp_folder = tempfile.gettempdir() for shot in shot_to_file: self.__update_progress( 'download quicktime for shot {0}'.format(shot), False) mov_path = os.path.join(temp_folder, shot_to_file[shot]['mov_name']) if sys.platform == 'win32' or sys.platform == 'cygwin': mov_path = mov_path.replace('\\', '\\\\') # Download quictime from Flix self.wg_flix_ui.get_flix_api().download_media_object( mov_path, mo_per_shots[shot].get('mov')) # Upload quicktime to shotgun version self.__update_progress( 'upload quicktime to shotgun for shot {0}'.format(shot), False) self.wg_shotgun_ui.get_shotgun_api().upload_movie( shot_to_file[shot]['version'], mov_path) except progress_canceled: print('progress cancelled') return self.__info('Latest sequence revision exported to shotgun')
def decode_audio(self): self.decoder.start() while not self.decoding_is_finished: QCoreApplication.processEvents() if self.decoder.bufferAvailable(): tempdata = self.decoder.read() # We use the Pointer Address to get a cffi Pointer to the data (hopefully) cast_data = self.audioformat_to_datatype(tempdata.format()) possible_data = ffi.cast("{1}[{0}]".format(tempdata.sampleCount(), cast_data), int(tempdata.constData())) self.only_samples.extend(possible_data) self.decoded_audio[self.decoder.position()] = [possible_data, len(possible_data), tempdata.byteCount(), tempdata.format()]
def _wait_for_segment_end(self, newstart, newlength): start = newstart * 1000.0 length = newlength * 1000.0 end = start + length while self.audio.position() < end: if not self.isplaying: return 0 QCoreApplication.processEvents() time.sleep(0.001) self.audio.stop() self.isplaying = False
def start_simulation(self): for i in range(1, (self.settings_bridge.epochs + 1)): self.epoch_bridge.epoch = i for j in range(101): self.epoch_bridge.progress = j QCoreApplication.processEvents() time.sleep(0.01) self.epoch_bridge.test_accuracy = min((i * i) * 3.978, 100) self.epoch_bridge.test_loss = 1 / i self.epoch_done.emit(self.epoch_bridge.epoch, self.epoch_bridge.test_loss) print('This is gonna be a longer Log message. Epoch ' + str(i) + ' done')
def _wait_for_segment_end(self, newstart, newlength): start = newstart * 1000.0 length = newlength * 1000.0 end = start + length print(start) print(length) print(end) while self.audio.position() < end: QCoreApplication.processEvents() print(self.audio.position()) time.sleep(0.001) self.audio.stop() self.isplaying = False
def __init__(self, soundfile, parent): self.soundfile = soundfile self.isplaying = False self.time = 0 # current audio position in frames self.audio = QMediaPlayer() self.is_loaded = False self.volume = 100 self.isplaying = False self.max_bits = 32768 # File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works self.audio.durationChanged.connect(self.on_durationChanged) # self.decoder.finished.connect(self.decode_finished_signal) self.audio.setMedia(QUrl.fromLocalFile(soundfile)) # self.decoder.setSourceFilename(soundfile) # strangely inconsistent file-handling # It will hang here forever if we don't process the events. while not self.is_loaded: QCoreApplication.processEvents() time.sleep(0.1) self.isvalid = True self.pydubfile = None if AudioSegment: if which("ffmpeg") is not None: AudioSegment.converter = which("ffmpeg") elif which("avconv") is not None: AudioSegment.converter = which("avconv") else: if platform.system() == "Windows": AudioSegment.converter = os.path.join( get_main_dir(), "ffmpeg.exe") # AudioSegment.converter = os.path.dirname(os.path.realpath(__file__)) + "\\ffmpeg.exe" else: # TODO: Check if we have ffmpeg or avconv installed AudioSegment.converter = "ffmpeg" try: if AudioSegment: print(self.soundfile) self.pydubfile = AudioSegment.from_file( self.soundfile, format=os.path.splitext(self.soundfile)[1][1:]) else: self.wave_reference = wave.open(self.soundfile) self.isvalid = True except: traceback.print_exc() self.wave_reference = None self.isvalid = False
def show_pairing(self, code: str, device_response: Callable[[], bool]) -> bool: dialog = BitBox02PairingDialog(code, device_response) dialog.show() # render the window since the next operation is blocking while True: QCoreApplication.processEvents() if dialog.painted: break time.sleep(0.1) if not device_response(): return False dialog.enable_buttons() dialog.exec_() return dialog.result() == QDialog.Accepted
def multiThreadUIMain(): # 这里采用了一个deepcopy的对象去做另一线程,该线程不涉及任何类的修改操作 # 这样做很不值得,但是如果在另一线程中使用self.vs会因为线程锁定而无法被pickle存储,即使线程已经关闭 jc = copy.deepcopy(self.job_config) class SJT(QThread): def __init__(self, job_submit_confg, *args): super().__init__() self.status = None self.jc = job_submit_confg self.args = args def run(self): self.status = self.jc.submit_job(self.args) thread = SJT(jc, self.selected_items) thread.start() #QMessageBox.information(self.main_window, "提示", "任务提交中......") error_msg = "任务提交失败,请检查\n1:服务器路径设置是否正确\n2:各文件路径是否有效\n3:Key Library是否按照说明书要求设置" while True: q = thread.status if q == None: QCoreApplication.processEvents() continue elif q == 1: try: # 提交成功才更新节点信息 thread.quit() thread.wait() del thread info = jc.update_XVI_nodel_info() if info == False: QMessageBox.information(self.main_window, "提示", "节点信息获取失败") self.vsp.update_xvi_item_info() self.update_xsd_files_information() QMessageBox.information(self.main_window, '提示', "任务已提交,若获取到任务节点信息即为提交成功") return except: traceback.print_exc() QMessageBox.critical(self.main_window, "错误", error_msg) return elif q == 0: QMessageBox.critical(self.main_window, "错误", error_msg) return
def create(self): """ Perform create operation :return:None """ assertMainThread() while self._operationInProgress and self._state != FilterState.CONSTRUCTING: QCoreApplication.processEvents() if self._state != FilterState.CONSTRUCTING: raise FilterStateMachineError(self._state, FilterState.CONSTRUCTING) self._operationInProgress = True self.performOperation.emit("create", Barrier(len(self._threads))) while self._state == FilterState.CONSTRUCTING: QCoreApplication.processEvents() self._operationInProgress = False
def closeEvent(self, event): Logger().debug("Chiusura applicazione") if isinstance(self.obs, Observer): if self.obs.isAlive(): Logger().info("Chiusura Observer") self.obs.stop() self.obs.join() Logger().info("Observer thread terminato") res = QMetaObject.invokeMethod(self.tailer, "stopProcess", Qt.BlockingQueuedConnection) QCoreApplication.processEvents() self.tailer.thread().wait() Logger().debug("Tailer listener thread terminato") super(MainWindow, self).closeEvent(event)
def __init__(self, soundfile, parent): self.soundfile = soundfile self.isplaying = False self.time = 0 # current audio position in frames self.audio = QMediaPlayer() self.is_loaded = False self.volume = 100 self.isplaying = False self.max_bits = 32768 # File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works self.audio.durationChanged.connect(self.on_durationChanged) # self.decoder.finished.connect(self.decode_finished_signal) self.audio.setMedia(QUrl.fromLocalFile(soundfile)) # self.decoder.setSourceFilename(soundfile) # strangely inconsistent file-handling # It will hang here forever if we don't process the events. self.audio_file = audioread.audio_open(self.soundfile) self.audio_data = [] for buf in self.audio_file: self.audio_data.extend( struct.unpack("<{}H".format(int(len(list(buf)) / 2)), buf)) print(self.audio_data) print(len(self.audio_data)) print(len(self.audio_data) / self.audio_file.samplerate) print(self.audio_file.duration) print(self.audio_file.channels) print("DATAEND") while not self.is_loaded: QCoreApplication.processEvents() time.sleep(0.1) self.isvalid = True self.pydubfile = None if AudioSegment: if which("ffmpeg") is not None: AudioSegment.converter = which("ffmpeg") elif which("avconv") is not None: AudioSegment.converter = which("avconv") else: if platform.system() == "Windows": AudioSegment.converter = os.path.join( get_main_dir(), "ffmpeg.exe") # AudioSegment.converter = os.path.dirname(os.path.realpath(__file__)) + "\\ffmpeg.exe" else: # TODO: Check if we have ffmpeg or avconv installed AudioSegment.converter = "ffmpeg" self.isvalid = True
def display(self, msg=None, pos=None): format_dict = self.format_dict elapsed_str = self.format_interval(format_dict['elapsed']) rate = format_dict['rate'] remaining = (self.total - self.n) / rate if rate and self.total else 0 remaining_str = self.format_interval(remaining) if rate else '??:??' time_str = f'Time remaining:\t{remaining_str}\nTime elapsed:\t{elapsed_str}' if not self._cancel_event.is_set(): self.dialog.setMaximum(self.total) if self.postfix: self.dialog.setLabelText(time_str + '\n\n' + self.postfix) else: self.dialog.setLabelText(time_str) self.dialog.setValue(self.n) QCoreApplication.processEvents()
def get_dirname(app=None): from PySide2.QtCore import Qt, QCoreApplication from PySide2.QtWidgets import QApplication, QFileDialog from pathlib import Path app = QApplication(sys.argv) file_dialog = QFileDialog() file_dialog.setWindowFlags(Qt.WindowStaysOnTopHint) file_location = file_dialog.getExistingDirectory() if file_location: QCoreApplication.processEvents() return Path(file_location) else: return None
def decode_audio(self): self.decoder.start() while not self.decoding_is_finished: QCoreApplication.processEvents() if self.decoder.bufferAvailable(): tempdata = self.decoder.read() # We use the Pointer Address to get a cffi Pointer to the data (hopefully) cast_data = self.audioformat_to_datatype(tempdata.format()) possible_data = ffi.cast( "{1}[{0}]".format(tempdata.sampleCount(), cast_data), int(tempdata.constData())) self.only_samples.extend(possible_data) self.decoded_audio[self.decoder.position()] = [ possible_data, len(possible_data), tempdata.byteCount(), tempdata.format() ]
def __init__(self, soundfile, parent): self.soundfile = soundfile self.isplaying = False self.time = 0 # current audio position in frames self.audio = QMediaPlayer() self.decoder = QAudioDecoder() self.is_loaded = False self.volume = 100 self.isplaying = False self.decoded_audio = {} self.only_samples = [] self.decoding_is_finished = False self.max_bits = 32768 self.signed = False # File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works self.audio.durationChanged.connect(self.on_durationChanged) self.decoder.finished.connect(self.decode_finished_signal) self.audio.setMedia(QUrl.fromLocalFile(soundfile)) self.decoder.setSourceFilename( soundfile) # strangely inconsistent file-handling self.top_level_widget = None for widget in QtWidgets.QApplication.topLevelWidgets(): if "lip_sync_frame" in dir(widget): self.top_level_widget = widget self.top_level_widget.lip_sync_frame.status_progress.show() self.top_level_widget.lip_sync_frame.status_progress.reset() self.top_level_widget.lip_sync_frame.status_progress.setMinimum(0) self.top_level_widget.lip_sync_frame.status_progress.setMaximum(0) # It will hang here forever if we don't process the events. while not self.is_loaded: QCoreApplication.processEvents() time.sleep(0.01) self.top_level_widget.lip_sync_frame.status_progress.setMaximum( self.decoder.duration()) self.decode_audio( self.top_level_widget.lip_sync_frame.status_bar_progress) self.top_level_widget.lip_sync_frame.status_progress.hide() self.np_data = np.array(self.only_samples) if not self.signed: # don't ask me why this fixes 8 bit samples... self.np_data = self.np_data - self.max_bits / 2 print(len(self.only_samples)) print(self.max_bits) self.isvalid = True
def __update_progress(self, message: str, skip_step: bool = True): """update_progress will update the progress message and will return False if the progress is 'canceled' by the user Arguments: message {str} -- Message to show in the progress skip_step {bool} -- Will skip the step (default: {True}) """ next_value = self.progress_start if skip_step is False: next_value = next_value + 1 self.progress_start = next_value self.progress.setValue(next_value) self.progress.setLabelText(message) self.progress.repaint() QCoreApplication.processEvents() if self.progress.wasCanceled(): raise progress_canceled
def on_show_all_clicked(self): if self.n_clusters > 20: self.show_warning( self. tr("N_clusters is greater than 20, it will generate too much windows on your screen." )) dataset, X, linkage_matrix, dendrogram_res = self.__last_result flags = fcluster(linkage_matrix, self.n_clusters, criterion="maxclust") flag_set = set(flags) rect = QApplication.primaryScreen().availableGeometry() x0 = rect.x() y0 = rect.y() max_w = rect.width() max_h = rect.height() span = 20 epoch = 0 w = 400 h = 300 x = x0 + epoch % 10 * 20 + span y = y0 + epoch % 10 * 20 + span span = 20 for flag in flag_set: samples = [] for sample, in_this_cluster in zip(dataset.samples, np.equal(flags, flag)): if in_this_cluster: samples.append(sample) chart = FrequencyCurveChart(parent=self, toolbar=True) chart.show_samples(samples, append=False, title=self.tr("Cluster{0}").format(flag)) chart.setGeometry(x, y, w, h) x += w + span if x > max_w - w: x = x0 + epoch % 10 * 40 + span y += h + span if y > max_h - h: epoch += 1 x = x0 + epoch % 10 * 40 + span y = x0 + epoch % 10 * 40 + span chart.show() QCoreApplication.processEvents()
def __init__(self, soundfile, parent): self.soundfile = soundfile self.isplaying = False self.time = 0 # current audio position in frames self.audio = QMediaPlayer() self.decoder = QAudioDecoder() self.is_loaded = False self.volume = 100 self.isplaying = False self.decoded_audio = {} self.only_samples = [] self.decoding_is_finished = False self.max_bits = 32768 # File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works self.audio.durationChanged.connect(self.on_durationChanged) #self.decoder.finished.connect(self.decode_finished_signal) self.audio.setMedia(QUrl.fromLocalFile(soundfile)) #self.decoder.setSourceFilename(soundfile) # strangely inconsistent file-handling # It will hang here forever if we don't process the events. while not self.is_loaded: QCoreApplication.processEvents() time.sleep(0.1) #self.decode_audio() #self.np_data = np.array(self.only_samples) #self.np_data = np.abs(self.np_data / self.max_bits) # A simple normalisation, with this the samples should all be between 0 and 1 # for i in self.decoded_audio.items(): # self.only_samples.extend(i[1][0]) # t = [] # for i in self.only_samples: # if i != []: # t.append(i + -(min(self.only_samples))) # # t2 = [] # for i in t: # t2.append(i / max(t)) # self.only_samples = t2 #print(len(self.only_samples)) #print(self.max_bits) self.isvalid = True self.pydubfile = None if AudioSegment: if which("ffmpeg") is not None: AudioSegment.converter = which("ffmpeg") elif which("avconv") is not None: AudioSegment.converter = which("avconv") else: if platform.system() == "Windows": AudioSegment.converter = os.path.join(get_main_dir(), "ffmpeg.exe") #AudioSegment.converter = os.path.dirname(os.path.realpath(__file__)) + "\\ffmpeg.exe" else: # TODO: Check if we have ffmpeg or avconv installed AudioSegment.converter = "ffmpeg" try: if AudioSegment: print(self.soundfile) self.pydubfile = AudioSegment.from_file(self.soundfile, format=os.path.splitext(self.soundfile)[1][1:]) else: self.wave_reference = wave.open(self.soundfile) self.isvalid = True except: traceback.print_exc() self.wave_reference = None self.isvalid = False