def run(self):
mutex = QMutex()
mutex.lock()
try:
if self.method == 'post':
response = self.session.post(self.url, data=self.data, files=self.files)
elif self.method == 'get':
response = self.session.get(self.url)
elif self.method == 'delete':
response = self.session.delete(self.url)
else:
raise Exception('不正确的方法')
if response.status_code >= 300:
try:
data = response.json()
if 'non_field_errors' in data:
error_message = data['non_field_errors']
else:
error_message = data.get('error', '未知错误')
message = '网络请求错误，错误码为{}，原因为{}'.format(response.status_code, error_message)
self.failed.emit(message)
except:
print(response.text)
else:
data = response.json()
self.success.emit(data)
except requests.Timeout as error:
self.failed.emit('网络请求错误，超时，请检查网络连接')
except BaseException as error:
print('BaseException'.format(error))
self.failed.emit(str(error.args))
finally:
mutex.unlock()
self.deleteLater()
def __init__(self, interval, project, vcs, parent=None):
"""
Constructor
@param interval new interval in seconds (integer)
@param project reference to the project object (Project)
@param vcs reference to the version control object
@param parent reference to the parent object (QObject)
"""
super(VcsStatusMonitorThread, self).__init__(parent)
self.setObjectName("VcsStatusMonitorThread")
self.setTerminationEnabled(True)
self.projectDir = project.getProjectPath()
self.project = project
self.vcs = vcs
self.interval = interval
self.autoUpdate = False
self.statusList = []
self.reportedStates = {}
self.shouldUpdate = False
self.monitorMutex = QMutex()
self.monitorCondition = QWaitCondition()
self.__stopIt = False
class Evaluate(QThread):
"""Thread used to insolate calculation process in entities (stream, project
and equipment, so gui can response while calculation is in process"""
def __init__(self, parent=None):
super(Evaluate, self).__init__(parent)
self.mutex = QMutex()
def start(self, entity, kwargs):
self.entity = entity
self.kwargs = kwargs
QThread.start(self)
def run(self):
self.mutex.lock()
self.entity(**self.kwargs)
self.mutex.unlock()
def __init__(self, weboob, parent=None):
QObject.__init__(self, parent)
self.weboob = weboob
self.weboob.callbacks['login'] = self.callback(self.LoginRequest)
self.mutex = QMutex()
self.requests = []
self.new_request.connect(self.do_request)
def __init__(self, weboob, parent=None):
super(QCallbacksManager, self).__init__(parent)
self.weboob = weboob
self.weboob.requests.register('login', self.callback(self.LoginRequest))
self.mutex = QMutex()
self.requests = []
self.new_request.connect(self.do_request)
def __init__(self, parent=None):
super(FortuneThread, self).__init__(parent)
self.quit = False
self.hostName = ''
self.cond = QWaitCondition()
self.mutex = QMutex()
self.port = 0
def __init__(self, parent=None):
super(FetchPage, self).__init__(parent)
print('thread initialized')
self.mutex = QMutex()
self.condition = QWaitCondition()
self.restart = False
self.abort = False
def __init__(self, plugin_id, address, socket):
QThread.__init__(self)
self.plugin_id = plugin_id
self.address = address
self.udp_socket = socket
self.finished.connect(self.quit)
self.wait = QWaitCondition()
self.mutex = QMutex()
def __init__(self, parent=None):
super(SyncAllThread, self).__init__(parent)
print("thread initialized")
self.mutex = QMutex()
self.condition = QWaitCondition()
self.restart = False
self.abort = False
def __init__(self, socket):
super(PugdebugServerConnection, self).__init__()
self.socket = socket
self.mutex = QMutex()
self.parser = PugdebugMessageParser()
class Console(QObject):
"""
The stream-like-object to redirect stream to Qt editor document
"""
update = pyqtSignal(str) # something is writen to console
def __init__(self, editor, color=None, parent=None, waitCond=None):
"""
:param editor: QTextBrowser or QPlainTextEditor etc.
:param color: text color
:return:
"""
super(Console, self).__init__(parent)
self.editor = editor
self.color = color
if self.color:
self.editor.setTextColor(self.color)
self.mutex = QMutex()
self.waitCond = waitCond
self.input = None
def write(self, content):
"""
Append to editor's document
:param content:
:return:
"""
self.update.emit(content)
def read(self):
self.editor.setReadOnly(False)
self.mutex.lock()
self.waitCond.wait(self.mutex)
self.mutex.unlock()
return self.input
def close(self):
pass
@pyqtSlot(str)
def receivedInput(self, content):
self.input = content
def __init__(self):
super().__init__()
self.queue = Queue()
self.mutex = QMutex()
self.enqueue_signal.connect(self.queue.put)
self.done_signal.connect(self.mutex.unlock)
self.start()
class QCallbacksManager(QObject):
class Request(object):
def __init__(self):
self.event = Event()
self.answer = None
def __call__(self):
raise NotImplementedError()
class LoginRequest(Request):
def __init__(self, backend_name, value):
super(QCallbacksManager.LoginRequest, self).__init__()
self.backend_name = backend_name
self.value = value
def __call__(self):
password, ok = QInputDialog.getText(None,
'%s request' % self.value.label,
'Please enter %s for %s' % (self.value.label,
self.backend_name),
QLineEdit.Password)
return password
new_request = Signal()
def __init__(self, weboob, parent=None):
super(QCallbacksManager, self).__init__(parent)
self.weboob = weboob
self.weboob.requests.register('login', self.callback(self.LoginRequest))
self.mutex = QMutex()
self.requests = []
self.new_request.connect(self.do_request)
def callback(self, klass):
def cb(*args, **kwargs):
return self.add_request(klass(*args, **kwargs))
return cb
@Slot()
def do_request(self):
self.mutex.lock()
request = self.requests.pop()
request.answer = request()
request.event.set()
self.mutex.unlock()
def add_request(self, request):
self.mutex.lock()
self.requests.append(request)
self.mutex.unlock()
self.new_request.emit()
request.event.wait()
return request.answer
def __init__(self, collection):
"""
Constructor
@param collection full pathname of the collection file (string)
"""
super(HelpDocsInstaller, self).__init__()
self.__abort = False
self.__collection = collection
self.__mutex = QMutex()
class Thread(QThread):
"""
단순히 0부터 100까지 카운트만 하는 쓰레드
값이 변경되면 그 값을 change_value 시그널에 값을 emit 한다.
"""
# 사용자 정의 시그널 선언
change_value = pyqtSignal(int)
def __init__(self):
QThread.__init__(self)
self.cond = QWaitCondition()
self.mutex = QMutex()
self.cnt = 0
self._status = True
def __del__(self):
self.wait()
def run(self):
while True:
self.mutex.lock()
if not self._status:
self.cond.wait(self.mutex)
if 100 == self.cnt:
self.cnt = 0
self.cnt += 1
self.change_value.emit(self.cnt)
self.msleep(100) # ※주의 QThread에서 제공하는 sleep을 사용
self.mutex.unlock()
def toggle_status(self):
self._status = not self._status
if self._status:
self.cond.wakeAll()
@property
def status(self):
return self._status
def __init__(self, inTxtWidget, projMan=None, parent=None):
'''
Define attributes.
Attributes
----------
inTxtWidget: QLineEdit
Input line widget of the main window.
projMan: Project
Object containing information about the project including
raw data and some parameters.
parent: QObject
Parent object.
'''
super().__init__(parent)
self.itw = inTxtWidget
self.projMan = projMan
# default analysis parameters
self.setBasic(self.loadDefault("basic"))
self.toStop = False
self.qm = QMutex()
class ReturnValue(Generic[T]):
"""Pass a return value from a slot back to the signal emitting thread.
The ReturnValue has to be send with the signal, the receiving
thread than calls .send() to set the value, while the calling
thread calls .receive() to wait until the value arrives."""
def __init__(self) -> None:
self._mutex = QMutex()
self._wait_condition = QWaitCondition()
self._value: Optional[T] = None
def receive(self) -> T:
self._mutex.lock()
while self._value is None:
self._wait_condition.wait(self._mutex)
self._mutex.unlock()
return self._value
def send(self, value: T) -> None:
self._value = value
self._wait_condition.wakeAll()
def __init__(self,loop):
super(UI,self).__init__()
self.sensor_mutex = QMutex()#loop.sensor_mutex
self.mirror_mutex = QMutex()#loop.mirror_mutex
self.loop = loop
try:
pass
self.loop.finished.connect(self.update)
except Exception as e:
pass
self.draw_boxes = ccfg.show_search_boxes
self.draw_lines = ccfg.show_slope_lines
self.init_UI()
self.frame_timer = FrameTimer('UI',verbose=False)
self.update_timer = BlockTimer('UI update method')
try:
self.profile_update_method = ccfg.profile_ui_update_method
except:
self.profile_update_method = False
self.show()
class FunctionThread(QThread):
executed = pyqtSignal(dict)
def __init__(self, parent=None):
super(FunctionThread, self).__init__(parent)
self.mutex = QMutex()
self.function = None
self.args = None
self.kwargs = None
self.returnValue = None
self.finished.connect(self.on_thread_finished)
self.done = True
def __del__(self):
self.wait()
def execute(self, function, *args, **kwargs):
locker = QMutexLocker(self.mutex)
self.function = function
self.args = args
self.kwargs = kwargs
self.done = False
self.start()
def run(self):
returnValue = self.function(*self.args, **self.kwargs)
self.mutex.lock()
self.returnValue = returnValue
self.mutex.unlock()
def on_thread_finished(self):
result = {'returnValue': self.returnValue}
self.done = True
self.executed.emit(result)
class AAThread(QThread):
# 시그널 선언
change_value = pyqtSignal(int)
def __init__(self, multi=10):
QThread.__init__(self)
self.cond = QWaitCondition()
self.mutex = QMutex()
self.count = 0
self._status = True
self.multi = multi
print(multi)
def set_multi(self, multi):
self.multi = multi
def set_count(self, value):
self.count = value
def __del__(self):
self.wait()
def run(self):
while True:
self.mutex.lock()
if not self._status:
self.cond.wait(self.mutex)
if 100 < self.count:
self.count = 0
self.count += 1
self.change_value.emit(self.count)
self.msleep(10000 // self.multi)
self.mutex.unlock()
@property
def status(self):
return self._status
def __init__(self, sequencelistmodel, parent=None, *args):
super().__init__(parent=parent, *args)
self.seqlist = sequencelistmodel
self._hwsoc = HWSOC()
self.mark = 0
self._steps = 0
self._sequence_cache = None
# thread locks
self.lock_running = QMutex()
self.lock_waiting = QMutex()
self.lock_waitcond = QWaitCondition()
self.lock_steps = QMutex()
# state variables
self.state_paused = False
self.state_running = False
self.state_waitinghwok = False
self.startTreatment.connect(self._startTreatment)
self.stopTreatment.connect(self._stopTreatment)
self.restartTreatment.connect(self._restartTreatment)
self.abortTreatment.connect(self._abortTreatment)
self.setHWOK.connect(self._sethwok)
# create QThread and move this object to it
self.thread = QThread()
self.moveToThread(self.thread)
self.thread.start()
def run(self):
self.t = 0.0
mutex = QMutex()
self.signals.start.emit()
self.reset(self.maxT, self.h)
while self.t < self.maxT:
if self.is_stop:
break
if self.is_pause:
continue
mutex.lock()
self.model.step(self.h, self.t)
mutex.unlock()
# pause time
self.t += self.h
# Emit drawing signal
self.signals.draw.emit(self.model)
time.sleep(0.01)
self.signals.finish.emit()
class Thread(QThread):
valueChange = pyqtSignal(int)
id_pipLine = pyqtSignal(list)
task_finished = pyqtSignal()
def __init__(self, results, *args, **kwargs):
super(Thread, self).__init__(*args, **kwargs)
# results 是从raw_datas查询的所有数据 一般以城市为条件查询
self.results = results
self._isPause = True
self._value = 1
self.cond = QWaitCondition()
self.mutex = QMutex()
def next(self):
print("下一组数据")
self._isPause = False
self.cond.wakeAll()
self._isPause = True
def run(self):
while True:
self.mutex.lock()
if self._isPause:
for i in self.results:
id = i[0]
company_id = i[1]
job_id = i[2]
item = [id, company_id, job_id]
# print(item)
self.id_pipLine.emit(item)
self.cond.wait(self.mutex)
if self._value == len(self.results):
self.task_finished.emit()
print('第{}组'.format(self._value))
self.valueChange.emit(self._value)
self._value += 1
self.mutex.unlock()
def __init__(self, camera, width, height, fps, exposure, gain, brightness, saving_interval,
saving_namespace, saving_path):
super(CameraWorker, self).__init__()
self.grab_flag = False # saving frames to file
self.quit_flag = False # flag to kill worker
self.change_params_flag = False # flag to change camera settings
self.status = True
self.frame_number = 0
self.save_roi = False
self.roi_origin = (0, 0)
self.roi_endpoint = (0, 0)
# camera params
self.fps = fps
self.width = width
self.height = height
self.exposure = exposure
self.gain = gain
self.brightness = brightness
# grab params
self.grab_directory = saving_path
self.grab_period = saving_interval
self.grab_namespace = saving_namespace
self.last_save_time = 0
self.mutex = QMutex()
self.raw_image = []
self.back_ground = []
try:
self.camera = cv2.VideoCapture(camera, cv2.CAP_DSHOW)
self.update_params()
ix = 0
while ix < 100:
self.camera.read()
ix = ix + 1
ret, self.back_ground = self.camera.read()
except Exception as ex:
print("Cam exp: ", ex)
self.backSub = cv2.createBackgroundSubtractorMOG2()
def __init__(self,
sharedImageBuffer,
deviceUrl,
dropFrameIfBufferFull,
apiPreference,
width,
height,
setting,
parent=None):
super(CaptureThread, self).__init__(parent)
self.t = QTime()
self.doStopMutex = QMutex()
self.fps = Queue()
# Save passed parameters
self.sharedImageBuffer = sharedImageBuffer
self.dropFrameIfBufferFull = dropFrameIfBufferFull
self.deviceUrl = deviceUrl
self._deviceUrl = int(deviceUrl) if deviceUrl.isdigit() else deviceUrl
self.localVideo = True if os.path.exists(self._deviceUrl) else False
self.apiPreference = apiPreference
self.width = width
self.height = height
# Initialize variables(s)
self.captureTime = 0
self.doStop = False
self.sampleNumber = 0
self.fpsSum = 0.0
self.statsData = ThreadStatisticsData()
self.defaultTime = 0
t = datetime.strptime(setting.skip_duration, '%H:%M:%S')
self.skip_duration = timedelta(hours=t.hour,
minutes=t.minute,
seconds=t.second)
self.video_date_time = datetime.strptime(
"{} {}".format(setting.video_date, setting.video_time),
'%d/%m/%Y %H:%M:%S')
self.starting_time = self.video_date_time
self.remain_video = None
self.pause = False
class WaitingData:
def __init__(self):
self.logger = logging.getLogger(constants.General.NAME)
self.__mutex = QMutex()
self.__condition = QWaitCondition()
self.__data = None
def wait(self):
self.__mutex.lock()
self.logger.debug(f'Lock: {self}')
self.__condition.wait(self.__mutex)
def wakeup(self, *args):
self.__condition.wakeAll()
self.__data = args
self.logger.debug(f'Unlock: {self}. Data: {args}')
def get_data(self) -> Optional[tuple]:
return self.__data
def __init__(self, parent=None):
super(FunctionThread, self).__init__(parent)
self.mutex = QMutex()
self.function = None
self.args = None
self.kwargs = None
self.returnValue = None
self.finished.connect(self.on_thread_finished)
self.done = True
class Run(QThread):
"""Run machine learning
"""
run_signal = pyqtSignal(str)
def __init__(self, ml_model, configuration_file):
super().__init__()
self.ml_model = ml_model
self.configuration_file = configuration_file
self.run_mut = QMutex()
def run(self):
"""This function is called when data_loading button is clicked.
Then, this function will process the data loading.
"""
self.run_mut.lock()
model = self.ml_model(self.configuration_file)
model.main_run()
self.run_mut.unlock()
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent object
@type QObject
"""
super(NetworkUrlInterceptor, self).__init__(parent)
self.__interceptors = []
self.__mutex = QMutex()
self.__loadSettings()
class Locked(Generic[T]):
"""Based off https://stackoverflow.com/a/37606669"""
def __init__(self, obj: T):
super().__init__()
self.obj = obj
self.lock = QMutex(QMutex.Recursive)
def __enter__(self) -> T:
self.lock.lock()
return self.obj
def __exit__(self, *args) -> None:
self.lock.unlock()
def set(self, value: T) -> T:
with self:
self.obj = value
return value
def get(self) -> T:
with self:
return self.obj
def __init__(self, camera, camera_params: CameraParams):
super().__init__()
self.camera_params = camera_params
self.logger = ErrorLogger(__name__)
self.camera_worker_params = CameraWorkerParams
self.mutex = QMutex()
self.raw_image = []
try:
self.camera = cv2.VideoCapture(camera, cv2.CAP_DSHOW)
self.update_params()
except Exception:
self.logger.logger.exception("Error"
" during camera parameters"
" setting and test image grabbing")
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Error")
msg.setInformativeText("Failed to init camera.")
msg.setWindowTitle("Error")
msg.exec_()
raise
def __init__(self, sharedImageBuffer, deviceUrl, cameraId, parent=None):
super(QThread, self).__init__(parent)
self.sharedImageBuffer = sharedImageBuffer
self.cameraId = cameraId
# Save Device Url
self.deviceUrl = deviceUrl
# Initialize members
self.doStopMutex = QMutex()
self.processingMutex = QMutex()
self.t = QTime()
self.processingTime = 0
self.doStop = False
self.enableFrameProcessing = False
self.sampleNumber = 0
self.fpsSum = 0.0
self.fps = Queue()
self.currentROI = QRect()
self.imgProcFlags = ImageProcessingFlags()
self.imgProcSettings = ImageProcessingSettings()
self.statsData = ThreadStatisticsData()
self.frame = None
self.currentFrame = None
def __init__(self, uid, pubkey, cache):
"""
Initializing a person object.
:param str uid: The person uid, also known as its uid on the network
:param str pubkey: The person pubkey
:param cache: The last returned values of the person properties.
"""
super().__init__()
self.uid = uid
self.pubkey = pubkey
self._cache = cache
self._cache_mutex = QMutex()
def setChangeFile(self, changeMsg):
"""
接收到平台要求改变文件目录的命令，暂停所有工作；改变工作目录和文件序列；线程重置；
再重启文件选择线程
:param changeMsg:
:return:
"""
if changeMsg:
#根据平台发来的信息进行重新初始化
self.timer4audiochoose.stop()
self.plainTextEdit.appendPlainText("INFO -- 系统收到新的文件命令,重启运行环境。")
mainlog("系统收到新的文件命令,重启运行环境。", "info")
self.file_path = changeMsg["file"]
self.lineEdit.setText(self.file_path)
self.tmpContent["file"] = self.file_path
file_num, self.fileDict = countWavFile(self.file_path)
self.lineEdit_2.setText("{:}".format(file_num))
if self.work4AudioChoose.isRunning():
try:
self.work4AudioChoose.disconnect()
self.work4AudioChoose.terminate()
if not self.work4AudioChoose.isFinished():
raise Exception("Closed Error")
except Exception as e:
mainlog("{}:停止音频选择线程错误".format(e), "error")
self.plainTextEdit.appendPlainText("ERROR --停止音频选择线程错误")
try:
self.mutex4audioprocess.unlock()
except:
pass
try:
self.mutex4audiochoose = QMutex()
except:
pass
self.work4AudioChoose = WorkThread4AudioChoose(
self.file_path, self.thread_num, self.fileDict,
self.threadDict, self.mutex4audiochoose)
self.work4AudioChoose.trigger.connect(self.procAudio)
self.timer4audiochoose.start(5000)
def initToolbar(self):
self.toolboxMutex = QMutex()
self.toolBarActions = {}
self.actionCasks = self.toolBar.addAction(
QIcon(
"icons/open_icon_library-mac/icons/32x32/categories/applications-other-4.icns"
), "Applications")
self.actionCasks.setCheckable(True)
self.actionCasks.triggered.connect(
lambda a: self.newSelect(a, self.actionCasks, "Casks"))
self.toolBarActions["Casks"] = self.actionCasks
self.actionLibs = self.toolBar.addAction(
QIcon(
"icons/open_icon_library-mac/icons/32x32/categories/applications-development-4.icns"
), "Libraries")
self.actionLibs.setCheckable(True)
self.actionLibs.triggered.connect(
lambda a: self.newSelect(a, self.actionLibs, "Libs"))
self.toolBarActions["Libs"] = self.actionLibs
self.actionUpdates = self.toolBar.addAction(
QIcon(
"icons/open_icon_library-mac/icons/32x32/actions/update_misc.icns"
), "Updates")
self.actionUpdates.setCheckable(True)
self.actionUpdates.triggered.connect(
lambda a: self.newSelect(a, self.actionUpdates, "Updates"))
self.toolBarActions["Updates"] = self.actionUpdates
self.actionQueue = self.toolBar.addAction(
QIcon(
"icons/open_icon_library-mac/icons/32x32/actions/arrow-right-double-3.icns"
), "Queue")
self.actionQueue.setCheckable(True)
self.actionQueue.triggered.connect(
lambda a: self.newSelect(a, self.actionQueue, "Queue"))
self.toolBarActions["Queue"] = self.actionQueue
class GetRecListsWorker(QThread):
'''获取回收站列表'''
folders = pyqtSignal(object)
infos = pyqtSignal(object, object)
msg = pyqtSignal(str, int)
def __init__(self, disk, parent=None):
super(GetRecListsWorker, self).__init__(parent)
self._disk = disk
self._mutex = QMutex()
self._is_work = False
self._folder_id = None
def set_values(self, fid):
# 用于获取回收站指定文件夹内文件信息
self._folder_id = fid
self.start()
def __del__(self):
self.wait()
def stop(self):
self._mutex.lock()
self._is_work = False
self._mutex.unlock()
def run(self):
if not self._is_work:
self._mutex.lock()
self._is_work = True
try:
if self._folder_id:
file_lists = self._disk.get_rec_file_list(
folder_id=self._folder_id)
self._folder_id = None
self.folders.emit(file_lists)
raise UserWarning
dir_lists = self._disk.get_rec_dir_list()
file_lists = self._disk.get_rec_file_list(folder_id=-1)
self.infos.emit(dir_lists, file_lists)
self.msg.emit("刷新列表成功！", 2000)
except TimeoutError:
self.msg.emit("网络超时，请稍后重试！", 6000)
except UserWarning:
pass
self._is_work = False
self._mutex.unlock()
else:
self.msg.emit("后台正在运行，请稍后重试！", 3100)
class LoadingBarThread(QThread):
change_value = pyqtSignal(int)
completed = pyqtSignal()
def __init__(self, parent):
QThread.__init__(self)
self.cond = QWaitCondition()
self.mutex = QMutex()
self.isRunning = True
self.parent = parent
def __del__(self):
self.wait()
def run(self):
self.cnt = 0
while True:
self.mutex.lock()
if not self.isRunning:
self.cond.wait(self.mutex)
if self.cnt == 50:
self.toggle_status()
if self.cnt == 100:
self.completed.emit()
break
self.cnt += 1
self.change_value.emit(self.cnt)
self.msleep(10)
self.mutex.unlock()
def toggle_status(self):
self.isRunning = not self.isRunning
if self.isRunning:
self.cond.wakeAll()
class Lock(object):
def __init__(self):
self._mutex = QMutex()
def __enter__(self):
self._mutex.lock()
def __exit__(self, type, value, tb):
self._mutex.unlock()
def acquire(self):
self._mutex.lock()
def release(self):
self._mutex.unlock()
class Tcp(QThread):
trigger = pyqtSignal()
def __init__(self, server, i, tb, parent=None):
super(Tcp, self).__init__(parent)
self.server = server
self.i = i
self.tb = tb
self.lock = QMutex()
# def __del__(self):
# self.wait()
def run(self):
# 处理你要做的业务逻辑，这里是通过一个回调来处理数据，这里的逻辑处理写自己的方法
# wechat.start_auto(self.callback)
# self._signal.emit(msg); 可以在这里写信号焕发
# self._signal.emit(msg)
ping = Ping.Ping(self.server["add"], int(self.server["port"]))
ping.ping(5)
time = ping.delay
if time == "0.00ms":
time = "连接超时"
self.lock.lock()
try:
self.tb.add_row(
[self.i,
str(self.i + 1) + "-" + self.server["ps"], time])
except:
pass
finally:
self.lock.unlock()
self.trigger.emit()
def callback(self, msg):
# 信号焕发，我是通过我封装类的回调来发起的
# self._signal.emit(msg)
pass
def __init__(self, parent=None):
super(domeGLWidget, self).__init__(parent)
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.z_trans = 300
self.x_trans = 0
self.y_trans = 0
self.z_near = 0.01
self.z_far = 5000.
self.frame_id = 0
self.last_frameid = 0
self.g_ambientLight = (0.35, 0.35, 0.35, 1.0)
self.g_diffuseLight = (0.75, 0.75, 0.75, 0.7)
self.g_specular = (1.0, 1.0, 1.0, 1.0)
self.lastPos = QPoint()
self.hdCams = []
self.smpl_Lists = []
self.ske_Lists = []
self.smpl = load_model(
'/home/xiul/workspace/SMPL_python/smpl/models/basicmodel_m_lbs_10_207_0_v1.0.0.pkl'
)
self.smpl_facenum = 0
self.smpl_params = []
self.vts_buffer = []
self.vns_buffer = []
self.inds_buffer = []
self.face_num = []
self.skeletons = []
self.render_lock = QMutex()
self.meshlib = meshWrapper(
lib_file=
'/home/xiul/workspace/PanopticDome/build/libPythonWrapper.so'
) # change this to your built shared library
self.meshlib.load_totalmodel()
def __init__(self):
super().__init__()
self._mutex = QMutex()
self._abort = False
self._condition = QWaitCondition()
self.cur_img = None
# load model and default graph
# self.classifier = keras.models.load_model('resnet_512.h5')
# self.graph = tf.get_default_graph() # REALLY IMPORTANT
# setup client
self.s = socket.socket() # Create a socket object
# host = socket.gethostname() # Get local machine name
host = "graphic02.doc.ic.ac.uk"
port = 12348 # Reserve a port for your service.
self.serverUp = True
try:
self.s.connect((host, port))
print('SERVER CONNECTED')
except Exception as e:
print('CANNOT CONNECT TO SERVER: ', e)
self.serverUp = False
def __init__(self, portName='', loglevel='WARNING'):
QThread.__init__(self)
self.logger = Logger(name='ratt.rfid')
self.logger.setLogLevelStr(loglevel)
self.debug = self.logger.isDebug()
self.cond = QWaitCondition()
self.mutex = QMutex()
self.portName = portName
self.waitTimeout = 250
self.quit = False
class Lock(object):
def __init__(self):
self._mutex = QMutex()
def __enter__(self):
self._mutex.lock()
def __exit__(self, type, value, tb):
self._mutex.unlock()
def acquire(self):
self._mutex.lock()
def release(self):
self._mutex.unlock()
def __init__(self, data: Dict, selection: Dict, properties: List[PropertyImportData]) -> None:
"""
:param data: import data parsed from the file to import
:param selection: dictionary of selected columns
"""
super().__init__()
self._logger = QGISLogHandler(self.__class__.__name__)
self._data: Dict = data
self._selection: Dict = selection
self._properties: List[PropertyImportData] = properties
self._mutex = QMutex()
self._cancel = False
self._message = ""
def allocReqId(self, req):
# TS is good enough
uid = str(time.time())
while uid in self.requests:
uid = str(time.time())
self.requests[uid] = {
'request': req,
'iodev': QBuffer(parent=req),
'mutex': QMutex() if not self.noMutexes else None
}
return uid
def __init__(self):
super(Ui, self).__init__()
# https://github.com/mherrmann/fbs/issues/32
uic.loadUi(appctxt.get_resource('main.ui'), self)
# `findChild(,'open')`非必需，比如uic会自动在此自动生成`self.open`
self.open_button = self.findChild(QtWidgets.QPushButton, 'open')
self.convert_button = self.findChild(QtWidgets.QPushButton, 'convertButton')
self.output_button = self.findChild(QtWidgets.QPushButton, 'output')
self.output_dir_edit = self.findChild(QtWidgets.QLineEdit, 'output_dir')
self.progress_bar = self.findChild(QtWidgets.QProgressBar, 'progressBar')
self.list_widget = self.findChild(QtWidgets.QListWidget, 'listWidget')
self.open_button.clicked.connect(self.open_button_pressed)
self.convert_button.clicked.connect(self.convert_button_pressed)
self.output_button.clicked.connect(self.output_button_pressed)
self.directory = None
self.entries = None
self.output_dir = None
self.mutex = QMutex()
self.thread_pool = QThreadPool()
self.thread_pool.setMaxThreadCount(os.cpu_count() - 1) # for not use all system cpu
self.show()
def __init__(self, source):
super(Tfi, self).__init__()
self.lock = QMutex()
self.fields = []
self.command_queue = [{
"callback": self._read_feed_vars,
"command": "get config.feed",
}]
self.sendCommand.connect(source.sendCommand)
source.packetArrived.connect(self.process_packet, Qt.QueuedConnection)
self._send_command()
class SyncEventHandler(QThread):
notify_signal = pyqtSignal(object)
enqueue_signal = pyqtSignal(object)
done_signal = pyqtSignal()
def __init__(self):
super().__init__()
self.queue = Queue()
self.mutex = QMutex()
self.enqueue_signal.connect(self.queue.put)
self.done_signal.connect(self.mutex.unlock)
self.start()
def done(self):
self.done_signal.emit()
def run(self):
while True:
self.mutex.lock()
event = self.queue.get()
self.notify_signal.emit(event)
class FetchPage(QThread):
fetchSignal = pyqtSignal(str, name='fetchComplete')
def __init__(self, parent=None):
super(FetchPage, self).__init__(parent)
print('thread initialized')
self.mutex = QMutex()
self.condition = QWaitCondition()
self.restart = False
self.abort = False
def __del__(self):
self.mutex.lock()
self.abort = True
self.condition.wakeOne()
self.mutex.unlock()
self.wait()
def fetch(self, page):
locker = QMutexLocker(self.mutex)
self.page = page
if page.content is not None:
print('Returning old content')
self.fetchSignal.emit(page.content)
else:
if not self.isRunning():
self.start(QThread.LowPriority)
else:
self.restart = True
self.condition.wakeOne()
def run(self):
print("running page fetch for " + self.page.title)
rest_api = RestAPI()
self.page.content = (rest_api.get_page_content(self.page.content_url))
# print(self.page.content)
self.fetchSignal.emit(self.page.content)
# self.fetchSignal.emit()
print('signal emitted')
self.mutex.lock()
if not self.restart:
self.condition.wait(self.mutex)
self.restart = False
self.mutex.unlock()
def __init__(self, editor, color=None, parent=None, waitCond=None):
"""
:param editor: QTextBrowser or QPlainTextEditor etc.
:param color: text color
:return:
"""
super(Console, self).__init__(parent)
self.editor = editor
self.color = color
if self.color:
self.editor.setTextColor(self.color)
self.mutex = QMutex()
self.waitCond = waitCond
self.input = None
def __init__(self, currency, nodes):
'''
Constructor of a network
:param str currency: The currency name of the community
:param list nodes: The root nodes of the network
'''
super().__init__()
self._root_nodes = nodes
self._nodes = []
self._mutex = QMutex()
self.currency = currency
self.nodes = nodes
self._must_crawl = False
self._is_perpetual = False
self._block_found = self.latest_block
def start_amp_watcher_thread(self):
# Set up thread to watch for manual changes of the amp
# controls at the amp (rather than gui) so we can update the
# gui controls as needed. The way this is done is inspired
# by:
# http://stackoverflow.com/questions/29243692/pyqt5-how-to-make-qthread-return-data-to-main-thread
# https://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/
self.watcher_thread = QThread()
self.amp_mutex = QMutex()
self.watcher = AmpControlWatcher(self.amp, self.amp_mutex)
self.watcher.have_data.connect(self.new_data_from_amp)
self.shutdown_threads.connect(self.watcher.stop_watching)
self.watcher.moveToThread(self.watcher_thread)
self.watcher_thread.started.connect(self.watcher.work)
self.watcher_thread.start()
def __init__(self, parent=None):
super(RenderThread, self).__init__(parent)
self.mutex = QMutex()
self.condition = QWaitCondition()
self.centerX = 0.0
self.centerY = 0.0
self.scaleFactor = 0.0
self.resultSize = QSize()
self.colormap = []
self.restart = False
self.abort = False
for i in range(RenderThread.ColormapSize):
self.colormap.append(self.rgbFromWaveLength(380.0 + (i * 400.0 / RenderThread.ColormapSize)))
class SyncAllThread(QThread):
syncCompleteSignal = pyqtSignal(Dbm, name="syncComplete")
def __init__(self, parent=None):
super(SyncAllThread, self).__init__(parent)
print("thread initialized")
self.mutex = QMutex()
self.condition = QWaitCondition()
self.restart = False
self.abort = False
def __del__(self):
self.mutex.lock()
self.abort = True
self.condition.wakeOne()
self.mutex.unlock()
self.wait()
def sync(self):
locker = QMutexLocker(self.mutex)
self.dbm = Dbm()
print("in sync thread")
if not self.isRunning():
self.start(QThread.LowPriority)
else:
self.restart = True
self.condition.wakeOne()
def run(self):
print("running sync thread")
self.dbm.fetch()
# print(self.page.content)
self.syncCompleteSignal.emit(self.dbm)
# self.fetchSignal.emit()
print("signal emitted")
self.mutex.lock()
if not self.restart:
self.condition.wait(self.mutex)
self.restart = False
self.mutex.unlock()
def __init__(self, parent=None):
super(Evaluate, self).__init__(parent)
self.mutex = QMutex()
def __init__(self):
self._mutex = QMutex()
class SwitchRefreshThread(QThread):
# Initialize class signals.
data_signal = pyqtSignal(bool)
"""
This function is responsible for initializing any related objects for
refresh thread.
"""
def __init__(self, plugin_id, address, socket):
QThread.__init__(self)
self.plugin_id = plugin_id
self.address = address
self.udp_socket = socket
self.finished.connect(self.quit)
self.wait = QWaitCondition()
self.mutex = QMutex()
"""
This is the entry point for refresh thread.
"""
def run(self):
# Run indefinately.
while True:
# Wait for trigger.
self.mutex.lock()
self.wait.wait(self.mutex)
self.mutex.unlock()
# Receive and discard any datagrams from this socket.
self.udp_socket.setblocking(0)
try:
while True:
_ = self.udp_socket.recv(65535)
except:
pass
self.udp_socket.setblocking(1)
self.udp_socket.settimeout(WV_REQ_TIMEOUT)
try:
rx_data = None
if DEBUG:
print("Sending an update request for", self.plugin_id, "to", self.address)
# Send a request update for this plugin.
self.udp_socket.sendto(bytes.fromhex(WV_UPDATE) + bytes([((self.plugin_id & 0xFF00) >> 8), (self.plugin_id & 0x00FF)]), self.address)
# Receive data form the UDP port.
rx_data = self.udp_socket.recv(65535)
# If we did receive a vaild reply.
if (rx_data[ : 4] == bytes.fromhex(WV_UPDATE_REPLY)):
# Remove packet descriptor.
rx_data = rx_data[4 : ]
# If we did receive some data.
if len(rx_data) == 1:
if DEBUG:
print("Got an update for", self.plugin_id, "from", self.address)
# Check if we are now turned on.
if (rx_data[0] == WV_PLUGIN_SWITCH_ON):
# Signal the data to update the plugin display.
self.data_signal.emit(True)
# Check if we are now turned off.
elif (rx_data[0] == WV_PLUGIN_SWITCH_OFF):
# Signal the data to append the plugin display.
self.data_signal.emit(False)
else:
if DEBUG:
print("Invalid header for", self.plugin_id, "from", self.address)
else:
if DEBUG:
print("No data received for", self.plugin_id, "from", self.address, "or invalid data was received")
else:
if DEBUG:
print("Invalid header for", self.plugin_id, "from", self.address)
except:
# Nothing to do here.
pass
class Ui(QMainWindow):
shutdown_threads = pyqtSignal(name='shutdown_threads')
def __init__(self):
super(Ui, self).__init__()
# Dictionary of methods to call in response to changes to
# controls made directly on the amplifier.
self.response_funcs = {
'voice': self.voice_changed_on_amp,
'gain': self.gain_changed_on_amp,
'volume': self.volume_changed_on_amp,
'bass': self.bass_changed_on_amp,
'middle': self.middle_changed_on_amp,
'treble': self.treble_changed_on_amp,
'isf': self.isf_changed_on_amp,
'tvp_switch': self.tvp_switch_changed_on_amp,
'tvp_valve': self.tvp_valve_changed_on_amp,
'mod_switch': self.mod_switch_changed_on_amp,
'delay_switch': self.delay_switch_changed_on_amp,
'reverb_switch': self.reverb_switch_changed_on_amp,
'mod_type': self.mod_type_changed_on_amp,
'mod_segval': self.mod_segval_changed_on_amp,
'mod_level': self.mod_level_changed_on_amp,
'mod_speed': self.mod_speed_changed_on_amp,
'mod_manual': self.mod_manual_changed_on_amp,
'delay_type': self.delay_type_changed_on_amp,
'delay_feedback': self.delay_feedback_changed_on_amp,
'delay_level': self.delay_level_changed_on_amp,
'delay_time': self.delay_time_changed_on_amp,
'reverb_type': self.reverb_type_changed_on_amp,
'reverb_size': self.reverb_size_changed_on_amp,
'reverb_level': self.reverb_level_changed_on_amp,
'fx_focus': self.fx_focus_changed_on_amp,
'preset': self.preset_changed_on_amp,
'manual_mode': self.manual_mode_changed_on_amp,
'tuner_mode': self.tuner_mode_changed_on_amp,
'tuner_note': self.tuner_note_changed_on_amp,
'tuner_delta': self.tuner_delta_changed_on_amp,
'resonance': self.resonance_changed_on_amp,
'presence': self.presence_changed_on_amp,
'master_volume': self.master_volume_changed_on_amp,
'preset_name': self.preset_name_from_amp,
'preset_settings': self.preset_settings_from_amp,
}
uif = os.path.join(os.path.split(__file__)[0], 'outsider.ui')
logger.debug('loading GUI file: {0}'.format(uif))
uic.loadUi(uif, self)
self.amp_mutex = None
self.amp = BlackstarIDAmp()
self.watcher_thread = None
# For now we don't do anything with preset settings
# information other than store them in this list
self.preset_settings = [None] * 128
self.controls_enabled(False)
self.show()
def controls_enabled(self, bool):
# Disable/Enable all widgets except the connect button (always enabled) and the master controls (always disabled)
if bool is True:
widgets = self.findChildren(QGroupBox)#(QObject)
for w in widgets:
if w == self.masterGroupBox:
pass
elif w.objectName() == 'TVPGroupBox' and self.amp.model == 'id-core':
# self.TVPComboBox.setCurrentText('6L6')
# self.TVPRadioButton.setChecked(False)
# Don't enable as Core has fixed TVP, probably with type 6L6
pass
else:
w.setEnabled(bool)
elif bool is False:
widgets = self.findChildren(QGroupBox)#(QObject)
for w in widgets:
w.setEnabled(bool)
widgets = self.findChildren(QSlider)
for w in widgets:
w.blockSignals(True)
w.setValue(0)
w.blockSignals(False)
widgets = self.findChildren(QLCDNumber)
for w in widgets:
w.blockSignals(True) # Not nescessary
w.display(0)
w.blockSignals(False) # Not nescessary
widgets = self.findChildren(QRadioButton)
for w in widgets:
w.blockSignals(True)
w.setChecked(False)
w.blockSignals(False)
def connect(self):
try:
self.amp.connect()
self.amp.drain()
self.start_amp_watcher_thread()
self.amp.startup()
self.amp.get_all_preset_names()
except NotConnectedError:
raise
def disconnect(self):
if self.watcher_thread is not None:
logger.debug('Closing down amplifier watching thread')
self.shutdown_threads.emit()
self.watcher_thread.quit()
self.watcher_thread.wait()
logger.debug('Amplifier watching thread finished')
if self.amp.connected is True:
self.amp.disconnect()
def start_amp_watcher_thread(self):
# Set up thread to watch for manual changes of the amp
# controls at the amp (rather than gui) so we can update the
# gui controls as needed. The way this is done is inspired
# by:
# http://stackoverflow.com/questions/29243692/pyqt5-how-to-make-qthread-return-data-to-main-thread
# https://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/
self.watcher_thread = QThread()
self.amp_mutex = QMutex()
self.watcher = AmpControlWatcher(self.amp, self.amp_mutex)
self.watcher.have_data.connect(self.new_data_from_amp)
self.shutdown_threads.connect(self.watcher.stop_watching)
self.watcher.moveToThread(self.watcher_thread)
self.watcher_thread.started.connect(self.watcher.work)
self.watcher_thread.start()
def closeEvent(self, event):
# Ran when the application is closed.
self.disconnect()
super(Ui, self).close()
logger.debug('Exiting')
@pyqtSlot(dict)
def new_data_from_amp(self, settings):
for control, value in settings.items():
try:
self.response_funcs[control](value)
except KeyError:
logger.error('Unrecognized control {0}'.format(control))
######################################################################
# The following methods are called when data is received from the amp
######################################################################
def voice_changed_on_amp(self, value):
self.voiceComboBox.blockSignals(True)
self.voiceComboBox.setCurrentIndex(value)
self.voiceComboBox.blockSignals(False)
def gain_changed_on_amp(self, value):
self.gainSlider.blockSignals(True)
self.gainSlider.setValue(value)
self.gainLcdNumber.display(value)
self.gainSlider.blockSignals(False)
def volume_changed_on_amp(self, value):
self.volumeSlider.blockSignals(True)
self.volumeSlider.setValue(value)
self.volumeLcdNumber.display(value)
self.volumeSlider.blockSignals(False)
def bass_changed_on_amp(self, value):
self.bassSlider.blockSignals(True)
self.bassSlider.setValue(value)
self.bassLcdNumber.display(value)
self.bassSlider.blockSignals(False)
def middle_changed_on_amp(self, value):
self.middleSlider.blockSignals(True)
self.middleSlider.setValue(value)
self.middleLcdNumber.display(value)
self.middleSlider.blockSignals(False)
def treble_changed_on_amp(self, value):
self.trebleSlider.blockSignals(True)
self.trebleSlider.setValue(value)
self.trebleLcdNumber.display(value)
self.trebleSlider.blockSignals(False)
def isf_changed_on_amp(self, value):
self.isfSlider.blockSignals(True)
self.isfSlider.setValue(value)
self.isfLcdNumber.display(value)
self.isfSlider.blockSignals(False)
def tvp_switch_changed_on_amp(self, value):
value = bool(value)
self.TVPRadioButton.blockSignals(True)
self.TVPRadioButton.setChecked(value)
self.TVPComboBox.setEnabled(value)
self.TVPRadioButton.blockSignals(False)
def tvp_valve_changed_on_amp(self, value):
self.TVPComboBox.blockSignals(True)
self.TVPComboBox.setCurrentIndex(value)
self.TVPComboBox.blockSignals(False)
def mod_switch_changed_on_amp(self, value):
value = bool(value)
self.modRadioButton.blockSignals(True)
self.modRadioButton.setChecked(value)
self.modComboBox.setEnabled(value)
self.modSegValSlider.setEnabled(value)
self.modSegValLabel.setEnabled(value)
self.modSegValLcdNumber.setEnabled(value)
self.modSpeedSlider.setEnabled(value)
self.modSpeedLabel.setEnabled(value)
self.modSpeedLcdNumber.setEnabled(value)
self.modLevelSlider.setEnabled(value)
self.modLevelLabel.setEnabled(value)
self.modLevelLcdNumber.setEnabled(value)
self.modRadioButton.blockSignals(False)
self.assess_manual_enabled()
def delay_switch_changed_on_amp(self, value):
value = bool(value)
self.delayRadioButton.blockSignals(True)
self.delayRadioButton.setChecked(value)
self.delayComboBox.setEnabled(value)
self.delayFeedbackSlider.setEnabled(value)
self.delayFeedbackLabel.setEnabled(value)
self.delayFeedbackLcdNumber.setEnabled(value)
self.delayTimeSlider.setEnabled(value)
self.delayTimeLabel.setEnabled(value)
self.delayTimeLcdNumber.setEnabled(value)
self.delayLevelSlider.setEnabled(value)
self.delayLevelLabel.setEnabled(value)
self.delayLevelLcdNumber.setEnabled(value)
self.delayRadioButton.blockSignals(False)
def reverb_switch_changed_on_amp(self, value):
value = bool(value)
self.reverbRadioButton.blockSignals(True)
self.reverbRadioButton.setChecked(value)
self.reverbComboBox.setEnabled(value)
self.reverbSizeSlider.setEnabled(value)
self.reverbSizeLabel.setEnabled(value)
self.reverbSizeLcdNumber.setEnabled(value)
self.reverbLevelSlider.setEnabled(value)
self.reverbLevelLabel.setEnabled(value)
self.reverbLevelLcdNumber.setEnabled(value)
self.reverbRadioButton.blockSignals(False)
def mod_type_changed_on_amp(self, value):
self.modComboBox.blockSignals(True)
self.modComboBox.setCurrentIndex(value)
self.modComboBox.blockSignals(False)
self.mod_type_changed(value)
def mod_segval_changed_on_amp(self, value):
self.modSegValSlider.blockSignals(True)
self.modSegValSlider.setValue(value)
self.modSegValLcdNumber.display(value)
self.modSegValSlider.blockSignals(False)
def mod_level_changed_on_amp(self, value):
self.modLevelSlider.blockSignals(True)
self.modLevelSlider.setValue(value)
self.modLevelLcdNumber.display(value)
self.modLevelSlider.blockSignals(False)
def mod_speed_changed_on_amp(self, value):
self.modSpeedSlider.blockSignals(True)
self.modSpeedSlider.setValue(value)
self.modSpeedLcdNumber.display(value)
self.modSpeedSlider.blockSignals(False)
def mod_manual_changed_on_amp(self, value):
self.modManualSlider.blockSignals(True)
self.modManualSlider.setValue(value)
self.modManualLcdNumber.display(value)
self.modManualSlider.blockSignals(False)
def delay_type_changed_on_amp(self, value):
self.delayComboBox.blockSignals(True)
self.delayComboBox.setCurrentIndex(value)
self.delayComboBox.blockSignals(False)
def delay_feedback_changed_on_amp(self, value):
self.delayFeedbackSlider.blockSignals(True)
self.delayFeedbackSlider.setValue(value)
self.delayFeedbackLcdNumber.display(value)
self.delayFeedbackSlider.blockSignals(False)
def delay_level_changed_on_amp(self, value):
self.delayLevelSlider.blockSignals(True)
self.delayLevelSlider.setValue(value)
self.delayLevelLcdNumber.display(value)
self.delayLevelSlider.blockSignals(False)
def delay_time_changed_on_amp(self, value):
self.delayTimeSlider.blockSignals(True)
self.delayTimeSlider.setValue(value)
self.delayTimeLcdNumber.display(value)
self.delayTimeSlider.blockSignals(False)
def reverb_type_changed_on_amp(self, value):
self.reverbComboBox.blockSignals(True)
self.reverbComboBox.setCurrentIndex(value)
self.reverbComboBox.blockSignals(False)
def reverb_size_changed_on_amp(self, value):
self.reverbSizeSlider.blockSignals(True)
self.reverbSizeSlider.setValue(value)
self.reverbSizeLcdNumber.display(value)
self.reverbSizeSlider.blockSignals(False)
def reverb_level_changed_on_amp(self, value):
self.reverbLevelSlider.blockSignals(True)
self.reverbLevelSlider.setValue(value)
self.reverbLevelLcdNumber.display(value)
self.reverbLevelSlider.blockSignals(False)
def fx_focus_changed_on_amp(self, value):
# This is a bit of a misnomer, as the amp doesn't emit data if
# the user changes the effect focus on the amp. However, when
# the user disables an effect in the GUI, if that effect had
# focus, we want to move the focus to another effect, if one
# is enabled. The way we do that, is in the slots associated
# with toggling an effect (see below), if the effect is
# disabled we issue a packet to query the state of all
# controls, which gives us an opportunity to react in this
# function here.
if value == 1 and not self.modRadioButton.isChecked():
if self.delayRadioButton.isChecked():
self.amp.set_control('fx_focus', 2)
elif self.reverbRadioButton.isChecked():
self.amp.set_control('fx_focus', 3)
elif value == 2 and not self.delayRadioButton.isChecked():
if self.reverbRadioButton.isChecked():
self.amp.set_control('fx_focus', 3)
elif self.modRadioButton.isChecked():
self.amp.set_control('fx_focus', 1)
if value == 3 and not self.reverbRadioButton.isChecked():
if self.modRadioButton.isChecked():
self.amp.set_control('fx_focus', 1)
elif self.delayRadioButton.isChecked():
self.amp.set_control('fx_focus', 2)
def preset_name_from_amp(self, namelist):
idx = namelist[0] - 1 # Presets are numbered from 1
name = str(namelist[0]) + '. ' + namelist[1]
item = self.presetNamesList.item(idx)
if item is None:
self.presetNamesList.insertItem(idx, name)
else:
item.setText(name)
def preset_settings_from_amp(self, settings):
self.preset_settings[settings.preset_number] = settings
def preset_changed_on_amp(self, value):
# TODO: This function is a stub for now, but will need hooking
# up to a combo box widget in the gui for selecting/indicating
# preset
logger.debug('preset changed on amp: {0}'.format(value))
self.presetNamesList.setCurrentRow(value - 1)
def manual_mode_changed_on_amp(self, value):
# TODO: This also needs hooking up to the preset combo box in
# the GUI
if value == 1:
# Here we'd need to set the combo box to "Manual"
pass
else:
# We're no longer in manual mode, but since in this case
# another packet will indicate the preset selected,
# there's no need to do anything here.
pass
logger.debug('manual_mode changed on amp: {0}'.format(value))
def tuner_mode_changed_on_amp(self, value):
# TODO: Stub for now - needs hooking into a suitable tuner widget
logger.debug('tuner_mode changed on amp: {0}'.format(value))
def tuner_note_changed_on_amp(self, value):
# TODO: Stub for now - needs hooking into a suitable tuner widget
logger.debug('tuner_note changed on amp: {0}'.format(value))
def tuner_delta_changed_on_amp(self, value):
# TODO: Stub for now - needs hooking into a suitable tuner widget
logger.debug('tuner_delta changed on amp: {0}'.format(value))
def resonance_changed_on_amp(self, value):
self.resonanceSlider.blockSignals(True)
self.resonanceSlider.setValue(value)
self.resonanceLcdNumber.display(value)
self.resonanceSlider.blockSignals(False)
logger.debug('resonance changed on amp: {0}'.format(value))
def presence_changed_on_amp(self, value):
self.presenceSlider.blockSignals(True)
self.presenceSlider.setValue(value)
self.presenceLcdNumber.display(value)
self.presenceSlider.blockSignals(False)
logger.debug('presence changed on amp: {0}'.format(value))
def master_volume_changed_on_amp(self, value):
self.masterVolumeSlider.blockSignals(True)
self.masterVolumeSlider.setValue(value)
self.masterVolumeLcdNumber.display(value)
self.masterVolumeSlider.blockSignals(False)
logger.debug('master_volume changed on amp: {0}'.format(value))
##################################################################
# The following methods are the slots for changes made on the gui
##################################################################
@pyqtSlot()
def on_connectToAmpButton_clicked(self):
if self.amp.connected is False:
try:
self.connect()
# Enable widgets
self.controls_enabled(True)
self.connectToAmpButton.setText('Disconnect Amp')
except NotConnectedError:
QMessageBox.information(self,'Outsider', 'No amplifier found')
else:
self.disconnect()
self.controls_enabled(False)
self.connectToAmpButton.setText('Connect to Amp')
@pyqtSlot(int)
def on_volumeSlider_valueChanged(self, value):
logger.debug('Volume slider: {0}'.format(value))
self.amp.set_control('volume', value)
@pyqtSlot(int)
def on_gainSlider_valueChanged(self, value):
logger.debug('Gain slider: {0}'.format(value))
self.amp.set_control('gain', value)
@pyqtSlot(int)
def on_bassSlider_valueChanged(self, value):
logger.debug('Bass slider: {0}'.format(value))
self.amp.set_control('bass', value)
@pyqtSlot(int)
def on_middleSlider_valueChanged(self, value):
logger.debug('Middle slider: {0}'.format(value))
self.amp.set_control('middle', value)
@pyqtSlot(int)
def on_trebleSlider_valueChanged(self, value):
logger.debug('Treble slider: {0}'.format(value))
self.amp.set_control('treble', value)
@pyqtSlot(int)
def on_isfSlider_valueChanged(self, value):
logger.debug('ISF slider: {0}'.format(value))
self.amp.set_control('isf', value)
@pyqtSlot(int)
def on_TVPComboBox_currentIndexChanged(self, idx):
logger.debug('TVP selection: {0}'.format(idx))
self.amp.set_control('tvp_valve', idx)
@pyqtSlot(bool)
def on_TVPRadioButton_toggled(self, state):
logger.debug('TVP switch: {0}'.format(state))
if state == True:
self.amp.set_control('tvp_switch', 1)
else:
self.amp.set_control('tvp_switch', 0)
@pyqtSlot(int)
def on_voiceComboBox_currentIndexChanged(self, idx):
logger.debug('Voice selection: {0}'.format(idx))
self.amp.set_control('voice', idx)
@pyqtSlot(bool)
def on_modRadioButton_toggled(self, state):
logger.debug('Mod switch: {0}'.format(state))
self.amp.set_control('mod_switch', state)
if state == 1:
self.amp.set_control('fx_focus', 1)
else:
# Find out if the mod effect had focus before being
# deactivated and shift focus to another effect if
# possible. The only mechanism we have available to do
# this is to get the status of all controls, sadly.
self.amp.startup()
self.assess_manual_enabled()
@pyqtSlot(int)
def on_modComboBox_currentIndexChanged(self, value):
logger.debug('Mod Combo Box: {0}'.format(value))
self.amp.set_control('mod_type', value)
self.amp.set_control('fx_focus', 1)
@pyqtSlot(int)
def on_modSegValSlider_valueChanged(self, value):
logger.debug('Mod SegVal slider: {0}'.format(value))
self.amp.set_control('mod_segval', value)
self.amp.set_control('fx_focus', 1)
@pyqtSlot(int)
def on_modLevelSlider_valueChanged(self, value):
logger.debug('Mod Level slider: {0}'.format(value))
self.amp.set_control('mod_level', value)
self.amp.set_control('fx_focus', 1)
@pyqtSlot(int)
def on_modSpeedSlider_valueChanged(self, value):
logger.debug('Mod Speed slider: {0}'.format(value))
self.amp.set_control('mod_speed', value)
self.amp.set_control('fx_focus', 1)
@pyqtSlot(int)
def on_modManualSlider_valueChanged(self, value):
logger.debug('Mod Manual slider: {0}'.format(value))
self.amp.set_control('mod_manual', value)
self.amp.set_control('fx_focus', 1)
@pyqtSlot(bool)
def on_delayRadioButton_toggled(self, state):
logger.debug('Delay switch: {0}'.format(state))
self.amp.set_control('delay_switch', state)
if state == 1:
self.amp.set_control('fx_focus', 2)
else:
# Find out if the mod effect had focus before being
# deactivated and shift focus to another effect if
# possible. The only mechanism we have available to do
# this is to get the status of all controls, sadly.
self.amp.startup()
@pyqtSlot(int)
def on_delayComboBox_currentIndexChanged(self, value):
logger.debug('Delay Combo Box: {0}'.format(value))
self.amp.set_control('delay_type', value)
self.amp.set_control('fx_focus', 2)
@pyqtSlot(int)
def on_delayFeedbackSlider_valueChanged(self, value):
logger.debug('Delay feedback slider: {0}'.format(value))
self.amp.set_control('delay_feedback', value)
self.amp.set_control('fx_focus', 2)
@pyqtSlot(int)
def on_delayLevelSlider_valueChanged(self, value):
logger.debug('Delay Level slider: {0}'.format(value))
self.amp.set_control('delay_level', value)
self.amp.set_control('fx_focus', 2)
@pyqtSlot(int)
def on_delayTimeSlider_valueChanged(self, value):
logger.debug('Delay Time slider: {0}'.format(value))
self.amp.set_control('delay_time', value)
self.amp.set_control('fx_focus', 2)
@pyqtSlot(bool)
def on_reverbRadioButton_toggled(self, state):
logger.debug('Reverb switch: {0}'.format(state))
self.amp.set_control('reverb_switch', state)
if state == 1:
self.amp.set_control('fx_focus', 3)
else:
# Find out if the mod effect had focus before being
# deactivated and shift focus to another effect if
# possible. The only mechanism we have available to do
# this is to get the status of all controls, sadly.
self.amp.startup()
@pyqtSlot(int)
def on_reverbComboBox_currentIndexChanged(self, value):
logger.debug('Reverb Combo Box: {0}'.format(value))
self.amp.set_control('reverb_type', value)
self.amp.set_control('fx_focus', 3)
@pyqtSlot(int)
def on_reverbSizeSlider_valueChanged(self, value):
logger.debug('Reverb Size slider: {0}'.format(value))
self.amp.set_control('reverb_size', value)
self.amp.set_control('fx_focus', 3)
@pyqtSlot(int)
def on_reverbLevelSlider_valueChanged(self, value):
logger.debug('Reverb Level slider: {0}'.format(value))
self.amp.set_control('reverb_level', value)
self.amp.set_control('fx_focus', 3)
@pyqtSlot(QListWidgetItem)
def on_presetNamesList_itemDoubleClicked(self, item):
idx = self.presetNamesList.currentRow()
preset = idx + 1 # Presets are numbered from 1
self.amp.select_preset(preset)
@pyqtSlot()
def on_renamePresetPushButton_clicked(self):
idx = self.presetNamesList.currentRow()
preset = idx + 1 # Presets are numbered from 1
name, ok = QInputDialog.getText(
self, 'Input Dialog',
'Enter new name for preset {0}:'.format(preset)
)
if ok == True:
# We need to grab the amp mutex to stop the amp watcher
# thread from consuming the packets emitted by the amp in
# the preset rename process
self.amp_mutex.lock()
self.amp.set_preset_name(preset, name)
self.amp_mutex.unlock()
# When the modulation type is changed, we want to change the label
# associated with the segment value control. So, we need to define
# a slot to trigger when the modulation type is changed, and a
# signal to raise to communicate back to the UI what the label
# should be changed to. The signal has argument type str, which is
# automatically converted to type QString.
mod_segval_label_update = pyqtSignal(str)
@pyqtSlot(int)
def mod_type_changed(self, value):
if value == 0:
self.mod_segval_label_update.emit('Mix')
elif value == 1:
self.mod_segval_label_update.emit('Feedback')
elif value == 2:
self.mod_segval_label_update.emit('Mix')
elif value == 3:
self.mod_segval_label_update.emit('FreqMod')
self.assess_manual_enabled()
@pyqtSlot(int)
def on_resonanceSlider_valueChanged(self, value):
logger.debug('Resonance slider: {0}'.format(value))
self.amp.set_control('resonance', value)
@pyqtSlot(int)
def on_presenceSlider_valueChanged(self, value):
logger.debug('Presence slider: {0}'.format(value))
self.amp.set_control('presence', value)
@pyqtSlot(int)
def on_masterVolumeSlider_valueChanged(self, value):
logger.debug('Master volume slider: {0}'.format(value))
self.amp.set_control('master_volume', value)
# When the modulation is enabled and the modution type is flanger, enable
# the manual control.
def assess_manual_enabled(self):
value = self.modRadioButton.isChecked() and self.modComboBox.currentIndex() == 1
self.modManualSlider.blockSignals(True)
self.modManualSlider.setEnabled(value)
self.modManualSlider.blockSignals(False)
class RenderThread(QThread):
ColormapSize = 512
renderedImage = pyqtSignal(QImage, float)
def __init__(self, parent=None):
super(RenderThread, self).__init__(parent)
self.mutex = QMutex()
self.condition = QWaitCondition()
self.centerX = 0.0
self.centerY = 0.0
self.scaleFactor = 0.0
self.resultSize = QSize()
self.colormap = []
self.restart = False
self.abort = False
for i in range(RenderThread.ColormapSize):
self.colormap.append(self.rgbFromWaveLength(380.0 + (i * 400.0 / RenderThread.ColormapSize)))
def __del__(self):
self.mutex.lock()
self.abort = True
self.condition.wakeOne()
self.mutex.unlock()
self.wait()
def render(self, centerX, centerY, scaleFactor, resultSize):
locker = QMutexLocker(self.mutex)
self.centerX = centerX
self.centerY = centerY
self.scaleFactor = scaleFactor
self.resultSize = resultSize
if not self.isRunning():
self.start(QThread.LowPriority)
else:
self.restart = True
self.condition.wakeOne()
def run(self):
while True:
self.mutex.lock()
resultSize = self.resultSize
scaleFactor = self.scaleFactor
centerX = self.centerX
centerY = self.centerY
self.mutex.unlock()
halfWidth = resultSize.width() // 2
halfHeight = resultSize.height() // 2
image = QImage(resultSize, QImage.Format_RGB32)
NumPasses = 8
curpass = 0
while curpass < NumPasses:
MaxIterations = (1 << (2 * curpass + 6)) + 32
Limit = 4
allBlack = True
for y in range(-halfHeight, halfHeight):
if self.restart:
break
if self.abort:
return
ay = 1j * (centerY + (y * scaleFactor))
for x in range(-halfWidth, halfWidth):
c0 = centerX + (x * scaleFactor) + ay
c = c0
numIterations = 0
while numIterations < MaxIterations:
numIterations += 1
c = c*c + c0
if abs(c) >= Limit:
break
numIterations += 1
c = c*c + c0
if abs(c) >= Limit:
break
numIterations += 1
c = c*c + c0
if abs(c) >= Limit:
break
numIterations += 1
c = c*c + c0
if abs(c) >= Limit:
break
if numIterations < MaxIterations:
image.setPixel(x + halfWidth, y + halfHeight,
self.colormap[numIterations % RenderThread.ColormapSize])
allBlack = False
else:
image.setPixel(x + halfWidth, y + halfHeight, qRgb(0, 0, 0))
if allBlack and curpass == 0:
curpass = 4
else:
if not self.restart:
self.renderedImage.emit(image, scaleFactor)
curpass += 1
self.mutex.lock()
if not self.restart:
self.condition.wait(self.mutex)
self.restart = False
self.mutex.unlock()
def rgbFromWaveLength(self, wave):
r = 0.0
g = 0.0
b = 0.0
if wave >= 380.0 and wave <= 440.0:
r = -1.0 * (wave - 440.0) / (440.0 - 380.0)
b = 1.0
elif wave >= 440.0 and wave <= 490.0:
g = (wave - 440.0) / (490.0 - 440.0)
b = 1.0
elif wave >= 490.0 and wave <= 510.0:
g = 1.0
b = -1.0 * (wave - 510.0) / (510.0 - 490.0)
elif wave >= 510.0 and wave <= 580.0:
r = (wave - 510.0) / (580.0 - 510.0)
g = 1.0
elif wave >= 580.0 and wave <= 645.0:
r = 1.0
g = -1.0 * (wave - 645.0) / (645.0 - 580.0)
elif wave >= 645.0 and wave <= 780.0:
r = 1.0
s = 1.0
if wave > 700.0:
s = 0.3 + 0.7 * (780.0 - wave) / (780.0 - 700.0)
elif wave < 420.0:
s = 0.3 + 0.7 * (wave - 380.0) / (420.0 - 380.0)
r = pow(r * s, 0.8)
g = pow(g * s, 0.8)
b = pow(b * s, 0.8)
return qRgb(r*255, g*255, b*255)
