class T_window(QWidget):
def __init__(self):
super().__init__()
self.tabs = QTabWidget()
self.com = T_communication()
self.pbar = QProgressBar()
self.pbar.setFormat("Battery : %p%")
self.grid = QGridLayout()
self.setLayout(self.grid)
self.grid.addWidget(self.pbar)
self.grid.addWidget(self.tabs)
self.dpi = T_dpi()
self.com.getDpi(self.dpi)
self.dpi.dataHasBeenSent()
self.t = []
for i in range(0, 4):
self.t.append(T_tab(i, self.dpi, self.com))
self.tabs.addTab(self.t[i], "Mode " + str(i + 1))
self.data = T_data(self.pbar, self.tabs, self.dpi, self.com)
for i in range(0, 4):
self.t[i].sendButton.clicked.connect(self.data.sendDpi)
self.t[i].resetButton.clicked.connect(self.com.resetDpi)
self.timer = QBasicTimer()
self.timer.start(100, self.data)
self.tabs.currentChanged.connect(self.com.sendMode)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.handleMouseEventPos(event.pos())
self.fLeftClickDown = True
else:
self.fLeftClickDown = False
QProgressBar.mousePressEvent(self, event)
class Loading(QWidget):
ON = False #to prevent multiple instances
def __init__(self):
from ..constants import WINDOW as parent
super().__init__(parent, Qt.FramelessWindowHint)
self.widget = QWidget(self)
self.widget.setStyleSheet("background-color:rgba(0, 0, 0, 0.65)")
self.progress = QProgressBar()
self.progress.setStyleSheet("color:white")
self.text = QLabel()
self.text.setAlignment(Qt.AlignCenter)
self.text.setStyleSheet("color:white;background-color:transparent;")
layout_ = QHBoxLayout()
inner_layout_ = QVBoxLayout()
inner_layout_.addWidget(self.text, 0, Qt.AlignHCenter)
inner_layout_.addWidget(self.progress)
self.widget.setLayout(inner_layout_)
layout_.addWidget(self.widget)
self.setLayout(layout_)
self.resize(300,100)
self.move(parent.window().rect().center()-QPoint(120,50))
def mousePressEvent(self, QMouseEvent):
pass
def setText(self, string):
if string != self.text.text():
self.text.setText(string)
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.progress_bar = QProgressBar(self)
self.progress_bar.setGeometry(30, 40, 200, 25)
self.btn = QPushButton('Start', self)
self.btn.move(30, 80)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('QProgressBar')
self.show()
def timerEvent(self, QTimerEvent):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step += 1
self.progress_bar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def main_process(self):
th = MyThread(10)
th.start()
for i in range(10):
print("main process")
sleep(2)
def initUI(self):
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
self.btn = QPushButton('Start', self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.main_process)
self.timer = QBasicTimer()
self.step = 0
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('QProgressBar')
self.show()
def __init__(self, parent=None):
"""
Initialize the progress bar.
:param parent: the parent widget
"""
QProgressBar.__init__(self, parent)
self.setFixedSize(300, 20)
class Loading(QWidget):
ON = False #to prevent multiple instances
def __init__(self, parent=None):
super().__init__(parent)
self.widget = QWidget(self)
self.progress = QProgressBar()
self.progress.setStyleSheet("color:white")
self.text = QLabel()
self.text.setAlignment(Qt.AlignCenter)
self.text.setStyleSheet("color:white;background-color:transparent;")
layout_ = QHBoxLayout()
inner_layout_ = QVBoxLayout()
inner_layout_.addWidget(self.text, 0, Qt.AlignHCenter)
inner_layout_.addWidget(self.progress)
self.widget.setLayout(inner_layout_)
layout_.addWidget(self.widget)
self.setLayout(layout_)
self.resize(300,100)
#frect = self.frameGeometry()
#frect.moveCenter(QDesktopWidget().availableGeometry().center())
self.move(parent.window().frameGeometry().topLeft() +
parent.window().rect().center() -
self.rect().center() - QPoint(self.rect().width()//2,0))
#self.setAttribute(Qt.WA_DeleteOnClose)
#self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)
def mousePressEvent(self, QMouseEvent):
pass
def setText(self, string):
if string != self.text.text():
self.text.setText(string)
def __init__(self, parent=None, numStages=1):
QDialog.__init__(self, parent)
self.threadRouter = ThreadRouter(self)
self.currentStep = 0
self.progress = None
l = QVBoxLayout()
self.setLayout(l)
self.overallProgress = QProgressBar()
self.overallProgress.setRange(0, numStages)
self.overallProgress.setFormat("step %v of "+str(numStages))
self.currentStepProgress = QProgressBar()
self.currentStepProgress.setRange(0, 100)
self.currentStepProgress.setFormat("%p %")
self.overallLabel = QLabel("Overall progress")
self.currentStepLabel = QLabel("Current step")
l.addWidget(self.overallLabel)
l.addWidget(self.overallProgress)
l.addWidget(self.currentStepLabel)
l.addWidget(self.currentStepProgress)
l.maximumSize()
self.update()
def mouseMoveEvent(self, event):
if self.fIsReadOnly:
return
if self.fLeftClickDown:
self.handleMouseEventPos(event.pos())
QProgressBar.mouseMoveEvent(self, event)
def paintEvent(self, event):
if self.fTextCall is not None:
self.setFormat("%s %s %s" % (self.fPreLabel, self.fTextCall(), self.fLabel))
elif self.fIsInteger:
self.setFormat("%s %i %s" % (self.fPreLabel, int(self.fRealValue), self.fLabel))
else:
self.setFormat("%s %f %s" % (self.fPreLabel, self.fRealValue, self.fLabel))
QProgressBar.paintEvent(self, event)
def setValue(self, value):
self.fRealValue = value
div = float(self.fMaximum - self.fMinimum)
if div == 0.0:
print("Parameter '%s' division by 0 prevented (value:%f, min:%f, max:%f)" % (self.fName, value, self.fMaximum, self.fMinimum))
vper = 1.0
else:
vper = float(value - self.fMinimum) / div
QProgressBar.setValue(self, int(vper * 10000))
class ProgressMessageBar(QObject):
def __init__(self, iface, message, minValue=10, delta=40, connector=None):
super(ProgressMessageBar, self).__init__()
self.iface = iface
self.minValue = minValue
self.delta = delta
self.progress = None
self.msgBar = None
self.aborted = False
if self.iface is not None:
self.msgBar = self.iface.messageBar().createMessage('DIVI',message)
self.progress = QProgressBar()
self.button = QPushButton(self.tr('Abort'))
self.msgBar.layout().addWidget(self.progress)
self.msgBar.layout().addWidget(self.button)
self.iface.messageBar().pushWidget(self.msgBar, Qgis.Info)
if connector is not None:
self.button.clicked.connect(connector.abort)
self.button.clicked.connect(self.abort)
def setProgress(self, value):
try:
progress = self.minValue+int(self.delta*value)
if self.iface is not None:
self.iface.mainWindow().statusBar().showMessage( self.tr("Loading layer {} %").format(progress) )
self.progress.setValue(progress)
except RuntimeError:
pass
def setValue(self, value):
try:
if self.iface is not None:
self.iface.mainWindow().statusBar().showMessage( self.tr("Loading layer {} %").format(value) )
self.progress.setValue(value)
except RuntimeError:
pass
def setBoundries(self, minValue=None, delta=None):
if minValue is not None:
self.minValue = minValue
if delta is not None:
self.delta = delta
def abort(self):
self.aborted = True
def close(self):
if self.iface is not None:
self.iface.messageBar().popWidget(self.msgBar)
self.progress = None
self.msgBar = None
class Example(QWidget):
def __init__(self):
super().__init__()
self.resize(640, 320)
self.setWindowTitle('PyQt-5 WebEngine')
page = "https://www.google.com"
self.url = QLineEdit(page)
self.url.setPlaceholderText(page)
self.go = QPushButton("Ir")
self.go.clicked.connect(self.btnIrClicked)
self.nav_bar = QHBoxLayout()
self.nav_bar.addWidget(self.url)
self.nav_bar.addWidget(self.go)
self.progress = QProgressBar()
self.progress.setValue(0)
html = """
<!DOCTYPE HTML>
<html>
<head>
<title>Example Local HTML</title>
</head>
<body>
<p>Este es un archivo <code>HTML</code> local.</p>
<p>Si deseas acceder página indica su <code>URL</code> y presiona <b>Ir</b></p>
</body>
</html>
"""
self.web_view = QWebEngineView()
self.web_view.loadProgress.connect(self.webLoading)
self.web_view.setHtml(html)
root = QVBoxLayout()
root.addLayout(self.nav_bar)
root.addWidget(self.web_view)
root.addWidget(self.progress)
self.setLayout(root)
def btnIrClicked(self, event):
url = QUrl(self.url.text())
self.web_view.page().load(url)
def webLoading(self, event):
self.progress.setValue(event)
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
self.btn = QPushButton('Start', self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.doAction)
# タイマー
self.timer = QBasicTimer()
self.step = 0
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('QProgressBar')
self.show()
def timerEvent(self, e):
# カウントが100に達すると終了
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
# 呼ばれるたび1ずつ増やす
self.step = self.step + 1
self.pbar.setValue(self.step)
def doAction(self):
"""ボタンが押されると呼ばれる"""
# タイマーが実行中ならタイマーを停止する
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
# タイマーが停止中ならタイマーを実行する
else:
# (timeout[ms], イベントの受取先)
# timeoutで指定した時間間隔でシグナルが飛ぶ模様
self.timer.start(1000, self)
self.btn.setText('Stop')
def __init__(self, parent):
QProgressBar.__init__(self, parent)
self.fLeftClickDown = False
self.fIsInteger = False
self.fIsReadOnly = False
self.fMinimum = 0.0
self.fMaximum = 1.0
self.fInitiated = False
self.fRealValue = 0.0
self.fLastPaintedValue = None
self.fCurrentPaintedText = ""
self.fLabel = ""
self.fName = ""
self.fPreLabel = " "
self.fTextCall = None
self.fValueCall = None
self.setFormat("(none)")
# Fake internal value, 10'000 precision
QProgressBar.setMinimum(self, 0)
QProgressBar.setMaximum(self, 10000)
QProgressBar.setValue(self, 0)
class ShipHp(QWidget):
def __init__(self, parent):
super(ShipHp, self).__init__(parent)
self.vbox = QVBoxLayout()
self.vbox.setSpacing(0)
self.vbox.setContentsMargins(0,3,0,3)
self.setLayout(self.vbox)
self.hp = QLabel(self)
#self.hp.setMinimumSize(QSize(0, 50))
self.vbox.addWidget(self.hp)
self.hp_bar = QProgressBar(self)
self.vbox.addWidget(self.hp_bar)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.hp_bar.setSizePolicy(sizePolicy)
self.hp_bar.setMinimumSize(QSize(100, 10))
self.hp_bar.setMaximumSize(QSize(100, 10))
self.vbox.addItem(QSpacerItem(40, 20,
QSizePolicy.Minimum,
QSizePolicy.Expanding))
def set_hp(self, hp, maxhp):
self.hp.setText(HP_FORMAT.format(hp, maxhp))
self.hp_bar.setValue(hp*100/maxhp)
self.hp_bar.setFormat('')
rate = float(hp) / float(maxhp)
if rate <= 0.25:
self.setProperty('damage', 'serious')
elif rate <= 0.50:
self.setProperty('damage', 'middle')
elif rate <= 0.75:
self.setProperty('damage', 'slight')
else:
self.setProperty('damage', 'none')
self.style().unpolish(self.hp_bar)
self.style().polish(self.hp_bar)
self.update()
# for apply stylesheet
def paintEvent(self, pe):
opt = QStyleOption()
opt.initFrom(self)
p = QPainter(self)
s = self.style()
s.drawPrimitive(QStyle.PE_Widget, opt, p, self)
def __init__(self, parent=None):
super(XNCStatusBar, self).__init__(parent)
# state vars
self.world = XNovaWorld_instance()
# initialization
self.setSizeGripEnabled(True)
# sub-widgets
# progressbar
self._progressbar = QProgressBar(self)
self._progressbar.hide()
self._progressbar.setValue(0)
self._progressbar.setRange(0, 99)
# online players counter
self._lbl_online = QLabel(self.tr('Online') + ': 0', self)
# label with loading.gif
self._loading_gif = QMovie(':/i/loading.gif')
self._lbl_loading = QLabel(self)
self._lbl_loading.setMovie(self._loading_gif)
self._lbl_loading.hide()
# testing only
self._btn_runscript = QPushButton('Run script', self)
self._btn_runscript.clicked.connect(self.on_run_script)
self.addPermanentWidget(self._btn_runscript)
#
self.addPermanentWidget(self._lbl_loading)
self.addPermanentWidget(self._lbl_online) # should be las right widget
self.show()
def __init__(self,
label_text="Progress:",
label_font_size=10,
bar_width=100,
use_bar=None,
label_on_left=True,
show_bar_text=False,
*args, **kwargs):
super().__init__(*args, **kwargs)
if use_bar:
self.bar = use_bar
else:
self.bar = QProgressBar(self)
self.bar.reset()
self.bar.setFixedWidth(bar_width)
self.bar.setTextVisible(show_bar_text)
self.label = QLabel(label_text, self)
self.label.setAlignment(Qt.AlignRight)
self.setStyleSheet("QLabel {font-size: %dpt}" % label_font_size)
layout = QHBoxLayout()
layout.setContentsMargins(0,0,0,0)
if label_on_left:
layout.addWidget(self.label)
layout.addWidget(self.bar)
else:
layout.addWidget(self.bar)
layout.addWidget(self.label)
self.setLayout(layout)
def ui_create(self):
#Add toolbar
self.toolBar = QToolBar()
self.toolBar.addAction(self.actionPageEmulation)
self.toolBar.setFloatable(False)
self.toolBar.setMovable(False)
self.toolBar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.gridLayout.addWidget(self.toolBar, 1, 0)
#Add a second toolbar on emulation page
self.toolBarEmulation = QToolBar()
self.toolBarEmulation.setFloatable(False)
self.toolBarEmulation.setMovable(False)
self.toolBarEmulation.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.pageEmulationLayout.addWidget(self.toolBarEmulation, 0, 0)
#Add progress bar to status bar
self.taskProgress = QProgressBar()
self.taskProgress.setVal = lambda x: ( self.taskProgress.setVisible(True), self.taskProgress.setValue(x) )
self.taskProgress.setVal(0)
self.taskProgress.setTextVisible(False)
self.statusBar.addPermanentWidget(self.taskProgress)
#Also print messages to terminal
self.statusBar.showMsg = lambda msg, timeout: ( logging.info(msg), self.statusBar.showMessage(msg, timeout) )
#Styling
self.setStyleSheet('QToolButton { padding-right: -3px; }')
def __init__(self):
QTreeWidgetItem.__init__(self)
self.download_info = None
self._logger = logging.getLogger('TriblerGUI')
bar_container = QWidget()
bar_container.setLayout(QVBoxLayout())
bar_container.setStyleSheet("background-color: transparent;")
self.progress_slider = QProgressBar()
# We have to set a zero pixel border to get the background working on Mac.
self.progress_slider.setStyleSheet("""
QProgressBar {
background-color: white;
color: black;
font-size: 12px;
text-align: center;
border: 0px solid transparent;
}
QProgressBar::chunk {
background-color: #e67300;
}
""")
bar_container.layout().addWidget(self.progress_slider)
bar_container.layout().setContentsMargins(4, 4, 8, 4)
self.progress_slider.setAutoFillBackground(True)
self.bar_container = bar_container
def __init__(self,winParent, pose3d):
super(percentajeWidget, self).__init__()
self.winParent=winParent
self.map = cv2.imread("resources/images/mapgrannyannie.png", cv2.IMREAD_GRAYSCALE)
self.map = cv2.resize(self.map, (500, 500))
image = QtGui.QImage(self.map.data, self.map.shape[1], self.map.shape[0], self.map.shape[1], QtGui.QImage.Format_Indexed8);
self.pixmap = QtGui.QPixmap.fromImage(image)
self.pose3d = pose3d
self.percentajeHouse = 0
self.numPixels = self.calculatePixelsWhite()
self.numPixelsWalked = 0
vLayout = QVBoxLayout()
self.percentajeWalked()
self.Percentaje = QLabel("Percentaje: " + str(round(self.percentajeHouse, 3)) + ' %')
vLayout.addWidget(self.Percentaje, 0)
self.bar = QProgressBar()
self.bar.setValue(self.percentajeHouse)
st = "QProgressBar::chunk {background-color: #ff0000;}\n QProgressBar {border: 1px solid grey;border-radius: 2px;text-align: center;background: #eeeeee;}"
self.bar.setStyleSheet(st)
self.bar.setTextVisible(False)
vLayout.addWidget(self.Percentaje, 0)
vLayout.addWidget(self.bar, 0)
vSpacer = QSpacerItem(30, 80, QSizePolicy.Ignored, QSizePolicy.Ignored)
vLayout.addItem(vSpacer)
self.setLayout(vLayout)
def initUI(self):
self.pbar = QProgressBar(self)
self.pbar.setObjectName('pbar')
self.pbar.setTextVisible(True)
self.pbar.setFormat('Configuring...')
self.timer = QBasicTimer()
self.step = 0
pixmap=QPixmap(':/Assets/moodly.gif')
lbl=QLabel(self)
lbl.setPixmap(pixmap)
hbox1=QHBoxLayout()
hbox1.addStretch(1)
hbox1.addWidget(lbl)
hbox1.addStretch(1)
hbox2=QHBoxLayout()
hbox2.addStretch(1)
hbox2.addWidget(self.pbar)
hbox2.addStretch(1)
vbox=QVBoxLayout()
vbox.addStretch(8)
vbox.addLayout(hbox1)
vbox.addStretch(1)
vbox.addLayout(hbox2)
vbox.addStretch(8)
self.setLayout(vbox)
self.callTimer()
def __init__(self):
super(MainWindow, self).__init__()
MainWindow._window_list.append(self)
self.setupUi(self)
# Qt Designer (at least to v4.2.1) can't handle arbitrary widgets in a
# QToolBar - even though uic can, and they are in the original .ui
# file. Therefore we manually add the problematic widgets.
self.lblAddress = QLabel("Address", self.tbAddress)
self.tbAddress.insertWidget(self.actionGo, self.lblAddress)
self.addressEdit = QLineEdit(self.tbAddress)
self.tbAddress.insertWidget(self.actionGo, self.addressEdit)
self.addressEdit.returnPressed.connect(self.actionGo.trigger)
self.actionBack.triggered.connect(self.WebBrowser.GoBack)
self.actionForward.triggered.connect(self.WebBrowser.GoForward)
self.actionStop.triggered.connect(self.WebBrowser.Stop)
self.actionRefresh.triggered.connect(self.WebBrowser.Refresh)
self.actionHome.triggered.connect(self.WebBrowser.GoHome)
self.actionSearch.triggered.connect(self.WebBrowser.GoSearch)
self.pb = QProgressBar(self.statusBar())
self.pb.setTextVisible(False)
self.pb.hide()
self.statusBar().addPermanentWidget(self.pb)
self.WebBrowser.dynamicCall('GoHome()')
def __init__(self, parent=None):
super(ErgebnissVorlage, self).__init__(parent)
self.auswahlAlter = QComboBox()
self.auswahlAlter.addItem("Bitte auswählen")
for i in range(3, 18):
self.auswahlAlter.addItem("{} Jahre / Jahrgang {}".format(i, date.today().year - i))
self.auswahlGeschlecht = QComboBox()
self.auswahlGeschlecht.addItem("Bitte auswählen")
self.auswahlGeschlecht.addItem("Männlich")
self.auswahlGeschlecht.addItem("Weiblich")
self.printerProgress = QProgressBar()
self.printerProgress.hide()
self.mainLayout = QFormLayout()
self.mainLayout.addRow(QLabel("Alter:"),self.auswahlAlter)
self.mainLayout.addRow(QLabel("Geschlecht:"),self.auswahlGeschlecht)
self.mainLayout.addRow(self.printerProgress)
self._drucken = QPushButton("Drucken")
self._drucken.clicked.connect(self.drucken)
self.mainLayout.addRow(self._drucken)
self.setLayout(self.mainLayout)
def add_progressbar(self):
"""Add separate progress bar to splash screen"""
self._progressBar = QProgressBar(self._splash)
self._progressBar.setGeometry(self._splash.width() / 10, 8 * self._splash.height() / 10,
8 * self._splash.width() / 10, self._splash.height() / 10)
self._progressBar.hide()
def start_download(self, filepath, path):
#thread = QThread(self)
pbar = QProgressBar(self.ui.tab_downloads)
pbar.setMinimum(0)
pbar.setMaximum(100)
pbar.setValue(0)
self.ui.formLayout.addRow(os.path.basename(path), pbar)
pbar.show()
dw = Downloader(str(filepath), str(path), pbar)
dw.finished.connect(self.finished_download)
dw.progresschanged.connect(self.show_download_progress)
dw.started.connect(self.started_download)
Thread(target=dw.download).start()
def createProgressBar(self):
self.progressBar = QProgressBar()
self.progressBar.setRange(0, 10000)
self.progressBar.setValue(0)
timer = QTimer(self)
timer.timeout.connect(self.advanceProgressBar)
timer.start(1000)
def extract2csv(self, tabWidget, d):
name = tabWidget.tabText(tabWidget.currentIndex())
wid = tabWidget.currentWidget()
start = wid.dateStart.text()
end = wid.dateEnd.text()
end = False if end == 'Now' else end
fail = []
progress = QProgressBar()
progress.setRange(0, len(self.tabCsv))
d.layout().addWidget(progress)
progress.setValue(0)
for i, device in enumerate(self.tabCsv[name]):
try:
dataFrame = self.db.dataBetween(device.tablename, ','.join(device.keys), start=start, end=end)
dataFrame.to_csv('/tmp/PFS-%s-%s.csv' % (start[:-6], device.tablename))
progress.setValue(i + 1)
except Exception as e:
print (e)
fail.append(device.tablename)
if fail:
self.showInformation("Extraction error on %s" % ','.join(fail))
else:
self.showInformation("Extraction Completed")
d.close()
class MyQt(QWidget):
def __init__(self):
super(MyQt, self).__init__()
self.initUI()
def initUI(self):
# 构建一个进度条
self.pbar = QProgressBar(self)
# 从左上角30-50的界面，显示一个200*25的界面
self.pbar.setGeometry(30, 50, 200, 25) # 设置进度条的位置
# 设置开始按钮
self.btn = QPushButton('开始', self)
self.btn.move(50, 90) # 按钮移动的位置
# 点击按钮
# 信号函数不能加括号
self.btn.clicked.connect(self.doAction)
# 构建一个计时器
self.timer = QBasicTimer()
# 计数
self.step = 0
self.setGeometry(300,300,280,170)
self.setWindowTitle('我是进度条')
self.setWindowIcon(QIcon('1.jpg'))
self.show()
def doAction(self):
# 判断是否处于激活状态
if self.timer.isActive():
self.timer.stop()
self.btn.setText('开始')
else:
self.timer.start(100,self)
self.btn.setText('停止')
def timerEvent(self, *args, **kwargs):
if self.step>=100:
# 停止进度条
self.timer.stop()
self.btn.setText('完成')
return
self.step+=1
# 把进度条每次充值的值赋给进图条
self.pbar.setValue(self.step)
def __init__(self, cue, **kwargs):
super().__init__(**kwargs)
self.cue = None
self._selected = False
self._accurate_timing = False
self._show_dbmeter = False
self._countdown_mode = True
self._dbmeter_element = None
self._fade_element = None
self.setAttribute(Qt.WA_TranslucentBackground)
self.setLayout(QGridLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(2)
self.layout().setColumnStretch(0, 6)
self.layout().setRowStretch(0, 4)
self.nameButton = QClickLabel(self)
self.nameButton.setObjectName('ButtonCueWidget')
self.nameButton.setWordWrap(True)
self.nameButton.setAlignment(Qt.AlignCenter)
self.nameButton.setFocusPolicy(Qt.NoFocus)
self.nameButton.clicked.connect(self._clicked)
self.nameButton.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.layout().addWidget(self.nameButton, 0, 0)
self.statusIcon = QLabel(self.nameButton)
self.statusIcon.setStyleSheet('background-color: transparent')
self.statusIcon.setPixmap(CueWidget.STOP.pixmap(CueWidget.ICON_SIZE,
CueWidget.ICON_SIZE))
self.seekSlider = QClickSlider(self.nameButton)
self.seekSlider.setOrientation(Qt.Horizontal)
self.seekSlider.setFocusPolicy(Qt.NoFocus)
self.seekSlider.setVisible(False)
self.dbMeter = QDbMeter(self)
self.dbMeter.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.dbMeter.setVisible(False)
self.timeBar = QProgressBar(self)
self.timeBar.setTextVisible(False)
self.timeBar.setLayout(QHBoxLayout())
self.timeBar.layout().setContentsMargins(0, 0, 0, 0)
self.timeDisplay = QLCDNumber(self.timeBar)
self.timeDisplay.setStyleSheet('background-color: transparent')
self.timeDisplay.setSegmentStyle(QLCDNumber.Flat)
self.timeDisplay.setDigitCount(8)
self.timeDisplay.display('00:00:00')
self.timeBar.layout().addWidget(self.timeDisplay)
self.timeBar.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
self.timeBar.setVisible(False)
self._set_cue(cue)
class MainWindow(QWidget):
def __init__(self, appctxt, config, configPath):
super().__init__()
self.lastOpenFoldPath = str(Path.home())
self.outputFileNameValue = ""
self.outputFoldPath = config['lastPath'] or str(Path.home())
self.splitWayValue = config['byWay']
self.config = config
self.appctxt = appctxt
self.configPath = configPath
self.initUI()
def initUI(self):
self.setAutoFillBackground(True)
pattern = self.palette()
pattern.setColor(QtGui.QPalette.Background, QColor("#EFFCFC"))
self.setPalette(pattern)
mainLayout = QVBoxLayout()
uploadButton = QPushButton()
uploadButton.setObjectName("upload")
uploadButton.setCursor(QtCore.Qt.PointingHandCursor)
uploadButton.clicked.connect(self.handleOpenPDF)
icon = QtGui.QIcon()
iconPath = appctxt.get_resource("images/pdf.png")
icon.addPixmap(QtGui.QPixmap(iconPath))
uploadButton.setIcon(icon)
uploadButton.setIconSize(QSize(30, 30))
note = QLabel(
'如何分页，默认为1，也可以自定义， Exp * [2] 表示每隔2页分隔成一个PDF * [2，3] 表示第一个文档取前2页，第二个文档取接下去的3页，3. * [1-2，3-5] 表示 1～2页分割成一个文档， 3～5页分割成一个文档'
)
note.setObjectName('note')
note.setWordWrap(True)
self.outputFileName = QLineEdit()
self.outputFileName.setPlaceholderText('输出文件名称')
self.outputFileName.setDisabled(True)
# self.compressCheckBox = QCheckBox()
# self.compressCheckBox.setText("输出文件是否打包压缩")
self.categoryByTime = QCheckBox()
self.categoryByTime.setText("输出文件夹按时间分类")
state = 0
if self.config['byTime'] == True:
state = 2
else:
state = 0
self.categoryByTime.setCheckState(state)
self.categoryByTime.stateChanged.connect(self.byTimeChecked)
self.categoryByTime.setDisabled(True)
self.outputFold = ClickableLineEdit()
self.outputFold.setText(self.outputFoldPath)
self.outputFold.setPlaceholderText("输出文件夹位置")
self.outputFold.clicked.connect(self.selectOutputFold)
self.outputFold.textChanged.connect(self.textChangedOutputFold)
self.outputFold.setDisabled(True)
doButton = QPushButton("执行")
doButton.setObjectName("do")
doButton.setCursor(QtCore.Qt.PointingHandCursor)
doButton.clicked.connect(self.handleSplitPDF)
doButton.setDisabled(True)
self.doButton = doButton
self.splitWay = QLineEdit()
self.splitWay.setText(self.splitWayValue)
self.splitWay.textChanged.connect(self.splitWayChange)
self.splitWay.setDisabled(True)
self.fileName = QLabel('文件名称')
self.pageNumber = QLabel("文件页数")
self.fileSize = QLabel("文件大小")
self.updateTime = QLabel("文件最近更新时间")
self.setLayout(mainLayout)
self.setGeometry(300, 200, 500, 600)
self.setWindowTitle('PDF 分割工具')
self.progressStatus = QProgressBar()
self.progressStatus.setObjectName("progressBar")
self.progressStatus.setGeometry(0, 0, 500, 20)
self.progressStatus.setMaximum(100)
self.progressStatus.setMinimum(0)
self.progressStatus.setTextVisible(False)
self.progressStatus.setVisible(False)
# self.progressStatus.setHidden(True)
headerGridGroup = QGroupBox()
bodyGridGroup = QGroupBox()
gridHeaderLayout = QGridLayout()
gridHeaderLayout.addWidget(uploadButton, 1, 1, 4, 1) # row 1 col 2
gridHeaderLayout.addWidget(self.fileName, 1, 2, 1, 1)
gridHeaderLayout.addWidget(self.pageNumber, 2, 2, 1, 1)
gridHeaderLayout.addWidget(self.fileSize, 3, 2, 1, 1)
gridHeaderLayout.addWidget(self.updateTime, 4, 2, 1, 1)
gridBodyLayout = QGridLayout()
gridBodyLayout.addWidget(self.outputFileName, 2, 1, 1,
2) # row 2 col 1
gridBodyLayout.addWidget(self.outputFold, 3, 1, 1, 2)
gridBodyLayout.addWidget(self.categoryByTime, 4, 1, 1, 2)
gridBodyLayout.addWidget(note, 7, 1, 1, 2)
gridBodyLayout.addWidget(self.splitWay, 8, 1, 1, 2)
gridBodyLayout.addWidget(doButton, 9, 2, 1, 1)
gridBodyLayout.addWidget(self.progressStatus, 10, 1, 1, 2)
headerGridGroup.setLayout(gridHeaderLayout)
bodyGridGroup.setLayout(gridBodyLayout)
mainLayout.addWidget(headerGridGroup)
mainLayout.addWidget(bodyGridGroup)
def byTimeChecked(self):
self.config['byTime'] = self.categoryByTime.isChecked()
self.updateConfigFile()
def textChangedOutputFold(self):
self.config['lastPath'] = self.outputFold.text()
self.updateConfigFile()
def splitWayChange(self):
self.config['byWay'] = self.splitWay.text()
self.updateConfigFile()
def selectOutputFold(self):
foldName = QFileDialog.getExistingDirectory(self, "选择存放文件夹")
self.outputFoldPath = str(foldName)
self.outputFold.setText(foldName)
def handleOpenPDF(self):
lastOpenFoldPath = self.lastOpenFoldPath
fname = QFileDialog.getOpenFileName(self, '打开PDF文件', lastOpenFoldPath,
"pdf(*.pdf)")
if fname[0]:
fileName = os.path.splitext(os.path.basename(fname[0]))[0]
fileSizeByte = os.path.getsize(fname[0])
fileSize = "{:.2f}".format(fileSizeByte / 1024 / 1024) + 'M'
updateTime = strftime("%Y-%m-%d %H:%M:%S",
gmtime(os.path.getmtime(fname[0])))
self.inputPDF = PdfFileReader(open(fname[0], "rb"))
pageNumber = str(self.inputPDF.numPages) + '页'
self.lastOpenFoldPath = str(
pathlib.Path(fname[0]).parent.absolute())
self.outputFileNameValue = fileName
self.fileName.setText('文件名：' + self.outputFileNameValue)
self.pageNumber.setText('PDF总页数：' + pageNumber)
self.fileSize.setText('文件大小：' + fileSize)
self.updateTime.setText('最近更新时间：' + updateTime)
outputName = os.path.splitext(fileName)[0]
self.outputFileName.setText(outputName)
self.outputFileName.setDisabled(False)
self.outputFold.setDisabled(False)
self.doButton.setDisabled(False)
self.outputFileName.setDisabled(False)
self.categoryByTime.setDisabled(False)
self.splitWay.setDisabled(False)
# 弹框展示错误信息
def showDialog(self, message):
msgBox = QMessageBox()
msgBox.setIcon(QMessageBox.Information)
msgBox.setText(message)
msgBox.exec()
# 信息验证
def checkInfomationValidate(self):
fileName = self.outputFileName.text()
outputPath = self.outputFold.text()
splitWay = self.splitWay.text()
if not len(fileName):
return {'status': False, "msg": "请填写需要输出的文件的名称"}
if not len(outputPath):
return {'status': False, 'msg': '请选择需要输出的文件的存放地址'}
if not len(splitWay):
return {'status': False, 'msg': '请指定分割方法'}
return {'status': True, 'msg': ''}
def updateConfigFile(self):
with open(self.configPath, 'w') as f:
json.dump(self.config, f)
def handleSetSplitWay(self):
pass
def handleSplitPDF(self):
self.checkInfomationValidate()
self.doButton.setVisible(False)
self.progressStatus.setVisible(True)
fileName = self.outputFileName.text()
outputPath = self.outputFold.text()
splitWay = self.splitWay.text()
# compress = self.compressCheckBox.checkState()
categoryByTime = self.categoryByTime.checkState()
# print(compress, categoryByTime)
funcWays = []
try:
ways = splitWay.split(",")
for i in ways:
stripText = i.strip()
if '-' in splitWay:
p = [int(i.strip()) for i in stripText.split('-')]
else:
p = int(i.strip())
funcWays.append(p)
except:
self.showDialog("指定文件分页方式有误！")
inputPDF = self.inputPDF
totalNumber = inputPDF.numPages
pages = []
def doPage(page, size, total):
t = [*range(page, page + size, 1)]
t = list(filter(lambda x: x <= total, t))
return t
if len(funcWays) == 1 and (not isinstance(funcWays[0], list)):
#固定分页
tmp = [*range(1, totalNumber + 1, funcWays[0])]
pages = [doPage(i, funcWays[0], totalNumber) for i in tmp]
else:
#自定义分页
if isinstance(funcWays[0], list):
# [[1,2], [3,4]
tmp = []
for i in funcWays:
t = [*range(i[0], i[1] + 1, 1)]
tmp.append(t)
pages = tmp
else:
tmp = []
start = 1
for i in funcWays:
end = start + i
if end > totalNumber:
end = totalNumber + 1
p = [*range(start, end, 1)]
start = p[-1] + 1
tmp.append(p)
pages = tmp
dirname = os.path.join(self.outputFoldPath, self.outputFileNameValue)
if categoryByTime == 2:
timeDir = strftime("%Y-%m-%d", gmtime())
dirname = os.path.join(self.outputFoldPath, timeDir,
self.outputFileNameValue)
print(self.outputFoldPath, timeDir, self.outputFileNameValue)
if not os.path.exists(dirname):
os.makedirs(dirname)
print("last pages", pages)
for i in pages:
output = PdfFileWriter()
for p in i:
if p <= totalNumber:
output.addPage(inputPDF.getPage(p - 1))
self.progressStatus.setValue(p % totalNumber * 100)
stri = []
if len(i) == 1:
stri = [str(d) for d in i]
else:
stri = [str(i[0]), str(i[-1])]
name = self.outputFileNameValue + '-'.join(stri) + '.pdf'
with open(os.path.join(dirname, name), "wb") as outputStream:
output.write(outputStream)
self.doButton.setVisible(True)
self.progressStatus.setVisible(False)
def _status_bar_add_progress_bar(self, stretch=0):
widget = QProgressBar()
self._layout_add_widget(self._status_bar_layout, widget, stretch)
return _QtWidget(widget)
class LabelAssistDialog(QDialog):
"""
A simple UI for showing bookmarks and navigating to them.
FIXME: For now, this window is tied to a particular lane.
If your project has more than one lane, then each one
will have it's own bookmark window, which is kinda dumb.
"""
def __init__(self, parent, topLevelOperatorView):
super(LabelAssistDialog, self).__init__(parent)
# Create thread router to populate table on main thread
self.threadRouter = ThreadRouter(self)
# Set object classification operator view
self.topLevelOperatorView = topLevelOperatorView
self.setWindowTitle("Label Assist")
self.setMinimumWidth(500)
self.setMinimumHeight(700)
layout = QGridLayout()
layout.setContentsMargins(10, 10, 10, 10)
# Show variable importance table
rows = 0
columns = 4
self.table = QTableWidget(rows, columns)
self.table.setHorizontalHeaderLabels(["Frame", "Max Area", "Min Area", "Labels"])
self.table.verticalHeader().setVisible(False)
# Select full row on-click and call capture double click
self.table.setSelectionBehavior(QTableView.SelectRows)
self.table.doubleClicked.connect(self._captureDoubleClick)
layout.addWidget(self.table, 1, 0, 3, 2)
# Create progress bar
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(0)
self.progressBar.hide()
layout.addWidget(self.progressBar, 4, 0, 1, 2)
# Create button to populate table
self.computeButton = QPushButton("Compute object info")
self.computeButton.clicked.connect(self._triggerTableUpdate)
layout.addWidget(self.computeButton, 5, 0)
# Create close button
closeButton = QPushButton("Close")
closeButton.clicked.connect(self.close)
layout.addWidget(closeButton, 5, 1)
# Set dialog layout
self.setLayout(layout)
def _triggerTableUpdate(self):
# Check that object area is included in selected features
featureNames = self.topLevelOperatorView.SelectedFeatures.value
if "Standard Object Features" not in featureNames or "Count" not in featureNames["Standard Object Features"]:
box = QMessageBox(
QMessageBox.Warning,
"Warning",
'Object area is not a selected feature. Please select this feature on: "Standard Object Features > Shape > Size in pixels"',
QMessageBox.NoButton,
self,
)
box.show()
return
# Clear table
self.table.clearContents()
self.table.setRowCount(0)
self.table.setSortingEnabled(False)
self.progressBar.show()
self.computeButton.setEnabled(False)
def compute_features_for_frame(tIndex, t, features):
# Compute features and labels (called in parallel from request pool)
roi = [slice(None) for i in range(len(self.topLevelOperatorView.LabelImages.meta.shape))]
roi[tIndex] = slice(t, t + 1)
roi = tuple(roi)
frame = self.topLevelOperatorView.SegmentationImages(roi).wait()
frame = frame.squeeze().astype(numpy.uint32, copy=False)
# Dirty trick: We don't care what we're passing here for the 'image' parameter,
# but vigra insists that we pass *something*, so we'll cast the label image as float32.
features[t] = vigra.analysis.extractRegionFeatures(
frame.view(numpy.float32), frame, ["Count"], ignoreLabel=0
)
tIndex = self.topLevelOperatorView.SegmentationImages.meta.axistags.index("t")
tMax = self.topLevelOperatorView.SegmentationImages.meta.shape[tIndex]
features = {}
labels = {}
def compute_all_features():
# Compute features in parallel
pool = RequestPool()
for t in range(tMax):
pool.add(Request(partial(compute_features_for_frame, tIndex, t, features)))
pool.wait()
# Compute labels
labels = self.topLevelOperatorView.LabelInputs([]).wait()
req = Request(compute_all_features)
req.notify_finished(partial(self._populateTable, features, labels))
req.submit()
@threadRouted
def _populateTable(self, features, labels, *args):
self.progressBar.hide()
self.computeButton.setEnabled(True)
for time, feature in features.items():
# Insert row
rowNum = self.table.rowCount()
self.table.insertRow(self.table.rowCount())
# Get max and min object areas
areas = feature["Count"] # objectFeatures['Standard Object Features']['Count']
maxObjArea = numpy.max(areas[numpy.nonzero(areas)])
minObjArea = numpy.min(areas[numpy.nonzero(areas)])
# Get number of labeled objects
labelNum = numpy.count_nonzero(labels[time])
# Load fram number
item = QTableWidgetItem(str(time))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 0, item)
# Load max object areas
item = QTableWidgetItemWithFloatSorting(str("{: .02f}".format(maxObjArea)))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 1, item)
# Load min object areas
item = QTableWidgetItemWithFloatSorting(str("{: .02f}".format(minObjArea)))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 2, item)
# Load label numbers
item = QTableWidgetItemWithFloatSorting(str("{: .01f}".format(labelNum)))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 3, item)
# Resize column size to fit dialog size
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
# Sort by max object area
self.table.setSortingEnabled(True)
self.table.sortByColumn(1, Qt.DescendingOrder)
def _captureDoubleClick(self):
# Navigate to selected frame
index = self.table.selectedIndexes()[0]
frameStr = self.table.item(index.row(), 0).text()
if frameStr:
frameNum = int(frameStr)
self.parent().editor.posModel.time = frameNum
def initLayout(self):
layout = QVBoxLayout(self)
## -- ROW 1
row = QHBoxLayout()
self.budgetProjection_btn = QPushButton()
self.budgetProjection_btn.setToolTip("Check Budget Projection...")
row.addWidget(self.budgetProjection_btn)
self.selectMN_btn = QPushButton("Select Masternodes...")
row.addWidget(self.selectMN_btn)
self.selectedMNlabel = QLabel(
"<em>0 masternodes selected for voting</em")
row.addWidget(self.selectedMNlabel)
row.addStretch(1)
self.statusLabel = QLabel("")
self.statusLabel.setMinimumWidth(116)
self.resetStatusLabel('<b style="color:red">Reload Proposals</b>')
row.addWidget(self.statusLabel)
row.addStretch(1)
self.mnCountLabel = QLabel()
row.addWidget(self.mnCountLabel)
self.refreshProposals_btn = QPushButton()
self.refreshProposals_btn.setToolTip("Refresh Proposal List")
row.addWidget(self.refreshProposals_btn)
self.toggleExpiring_btn = QPushButton("Hide Expiring")
self.toggleExpiring_btn.setToolTip(
"Hide expiring proposals (yellow background) from list")
row.addWidget(self.toggleExpiring_btn)
layout.addLayout(row)
## -- ROW 2
self.proposalBox = QTableWidget()
self.proposalBox.setMinimumHeight(280)
self.proposalBox.setSelectionMode(QAbstractItemView.MultiSelection)
self.proposalBox.setSelectionBehavior(QAbstractItemView.SelectRows)
self.proposalBox.setShowGrid(True)
self.proposalBox.setColumnCount(8)
self.proposalBox.setRowCount(0)
self.proposalBox.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.proposalBox.setSortingEnabled(True)
#self.proposalBox.verticalHeader().hide
self.setProposalBoxHeader()
self.proposalBox.setColumnWidth(1, 50)
self.proposalBox.setColumnWidth(2, 50)
self.proposalBox.setColumnWidth(3, 100)
self.proposalBox.setColumnWidth(4, 100)
self.proposalBox.setColumnWidth(5, 150)
self.proposalBox.setColumnWidth(6, 120)
self.proposalBox.setColumnWidth(7, 50)
layout.addWidget(self.proposalBox)
## -- ROW 3
row = QHBoxLayout()
self.timeIconLabel = QLabel()
self.timeIconLabel.setToolTip(
"Check to add a randomized time offset (positive or negative) to enhance privacy"
)
row.addWidget(self.timeIconLabel)
self.randomDelayCheck = QCheckBox()
self.randomDelayCheck.setToolTip(
"Check to add a randomized time offset when voting (max +5/-5 hrs)"
)
row.addWidget(self.randomDelayCheck)
self.randomDelayNeg_edt = QSpinBox()
self.randomDelayNeg_edt.setPrefix('- ')
self.randomDelayNeg_edt.setSuffix(" secs")
self.randomDelayNeg_edt.setToolTip(
"Maximum random time (in seconds) subtracted from each vote timestamp"
)
self.randomDelayNeg_edt.setFixedWidth(100)
self.randomDelayNeg_edt.setMaximum(18000)
self.randomDelayNeg_edt.setValue(0)
row.addWidget(self.randomDelayNeg_edt)
self.randomDelayPos_edt = QSpinBox()
self.randomDelayPos_edt.setPrefix("+ ")
self.randomDelayPos_edt.setSuffix(" secs")
self.randomDelayPos_edt.setToolTip(
"Maximum random time (in seconds) added to each vote timestamp")
self.randomDelayPos_edt.setFixedWidth(100)
self.randomDelayPos_edt.setMaximum(18000)
self.randomDelayPos_edt.setValue(300)
row.addWidget(self.randomDelayPos_edt)
row.addStretch(1)
self.loadingLine = QLabel(
"<b style='color:red'>Vote Signatures.</b> Completed: ")
self.loadingLinePercent = QProgressBar()
self.loadingLinePercent.setMaximumWidth(200)
self.loadingLinePercent.setMaximumHeight(10)
self.loadingLinePercent.setRange(0, 100)
row.addWidget(self.loadingLine)
row.addWidget(self.loadingLinePercent)
self.loadingLine.hide()
self.loadingLinePercent.hide()
row.addStretch(1)
self.selectedPropLabel = QLabel("<em>0 proposals selected</em>")
row.addWidget(self.selectedPropLabel)
self.questionLabel = QLabel()
message = "Refresh proposals.\n"
message += "GREEN: proposal passing\n"
message += "WHITE: missing votes in order to pass\n"
message += "RED: proposal not passing\n"
message += "YELLOW: proposal expiring (last payment block)\n"
self.questionLabel.setToolTip(message)
row.addWidget(self.questionLabel)
layout.addLayout(row)
## -- ROW 4
row = QHBoxLayout()
self.voteYes_btn = QPushButton("Vote YES")
self.voteYes_btn.setToolTip("Vote YES on selected proposals")
row.addWidget(self.voteYes_btn)
self.voteAbstain_btn = QPushButton("Vote ABSTAIN")
self.voteAbstain_btn.setToolTip(
"Vote ABSTAIN on selected proposals [currently disabled]")
row.addWidget(self.voteAbstain_btn)
self.voteNo_btn = QPushButton("Vote NO")
self.voteNo_btn.setToolTip("Vote NO on selected proposals")
row.addWidget(self.voteNo_btn)
layout.addLayout(row)
class RechgEvalWidget(QFrameLayout):
sig_new_gluedf = QSignal(GLUEDataFrameBase)
def __init__(self, parent):
super(RechgEvalWidget, self).__init__(parent)
self.setWindowTitle('Recharge Calibration Setup')
self.setWindowFlags(Qt.Window)
self.wxdset = None
self.wldset = None
self.figstack = FigureStackManager(parent=self)
self.progressbar = QProgressBar()
self.progressbar.setValue(0)
self.progressbar.hide()
self.__initUI__()
# Set the worker and thread mechanics
self.rechg_worker = RechgEvalWorker()
self.rechg_worker.sig_glue_finished.connect(self.receive_glue_calcul)
self.rechg_worker.sig_glue_progress.connect(self.progressbar.setValue)
self.rechg_thread = QThread()
self.rechg_worker.moveToThread(self.rechg_thread)
self.rechg_thread.started.connect(self.rechg_worker.eval_recharge)
def __initUI__(self):
class QRowLayout(QWidget):
def __init__(self, items, parent=None):
super(QRowLayout, self).__init__(parent)
layout = QGridLayout()
for col, item in enumerate(items):
layout.addWidget(item, 0, col)
layout.setContentsMargins(0, 0, 0, 0)
layout.setColumnStretch(0, 100)
self.setLayout(layout)
# ---- Parameters
# Specific yield (Sy) :
self.QSy_min = QDoubleSpinBox(0.05, 3)
self.QSy_min.setRange(0.001, 1)
self.QSy_max = QDoubleSpinBox(0.2, 3)
self.QSy_max.setRange(0.001, 1)
# Maximum readily available water (RASmax) :
# units=' mm'
self.QRAS_min = QDoubleSpinBox(5)
self.QRAS_min.setRange(0, 999)
self.QRAS_max = QDoubleSpinBox(40)
self.QRAS_max.setRange(0, 999)
# Runoff coefficient (Cro) :
self.CRO_min = QDoubleSpinBox(0.1, 3)
self.CRO_min.setRange(0, 1)
self.CRO_max = QDoubleSpinBox(0.3, 3)
self.CRO_max.setRange(0, 1)
# Snowmelt parameters :
# units=' °C'
self._Tmelt = QDoubleSpinBox(0, 1)
self._Tmelt.setRange(-25, 25)
# units=' mm/°C'
self._CM = QDoubleSpinBox(
4,
1,
0.1,
)
self._CM.setRange(0.1, 100)
# units=' days'
self._deltaT = QDoubleSpinBox(
0,
0,
)
self._deltaT.setRange(0, 999)
class QLabelCentered(QLabel):
def __init__(self, text):
super(QLabelCentered, self).__init__(text)
self.setAlignment(Qt.AlignCenter)
# ---- Parameters
params_group = QFrameLayout()
params_group.setContentsMargins(10, 5, 10, 0) # (L, T, R, B)
params_group.setObjectName("viewport")
params_group.setStyleSheet("#viewport {background-color:transparent;}")
row = 0
params_group.addWidget(QLabel('Sy :'), row, 0)
params_group.addWidget(self.QSy_min, row, 1)
params_group.addWidget(QLabelCentered('to'), row, 2)
params_group.addWidget(self.QSy_max, row, 3)
row += 1
params_group.addWidget(QLabel('RAS<sub>max</sub> :'), row, 0)
params_group.addWidget(self.QRAS_min, row, 1)
params_group.addWidget(QLabelCentered('to'), row, 2)
params_group.addWidget(self.QRAS_max, row, 3)
params_group.addWidget(QLabel('mm'), row, 4)
row += 1
params_group.addWidget(QLabel('Cro :'), row, 0)
params_group.addWidget(self.CRO_min, row, 1)
params_group.addWidget(QLabelCentered('to'), row, 2)
params_group.addWidget(self.CRO_max, row, 3)
row += 1
params_group.setRowMinimumHeight(row, 10)
row += 1
params_group.addWidget(QLabel('Tmelt :'), row, 0)
params_group.addWidget(self._Tmelt, row, 1)
params_group.addWidget(QLabel('°C'), row, 2, 1, 3)
row += 1
params_group.addWidget(QLabel('CM :'), row, 0)
params_group.addWidget(self._CM, row, 1)
params_group.addWidget(QLabel('mm/°C'), row, 2, 1, 3)
row += 1
params_group.addWidget(QLabel('deltaT :'), row, 0)
params_group.addWidget(self._deltaT, row, 1)
params_group.addWidget(QLabel('days'), row, 2, 1, 3)
row += 1
params_group.setRowStretch(row, 100)
params_group.setColumnStretch(5, 100)
# ---- Layout ----
qtitle = QLabel('Parameter Range')
qtitle.setAlignment(Qt.AlignCenter)
sa = QScrollArea()
sa.setWidget(params_group)
sa.setWidgetResizable(True)
sa.setFrameStyle(0)
sa.setStyleSheet("QScrollArea {background-color:transparent;}")
sa.setSizePolicy(
QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred))
# ---- Main Layout
self.addWidget(qtitle, 0, 0)
self.addWidget(HSep(), 1, 0)
self.addWidget(sa, 2, 0)
self.addWidget(HSep(), 3, 0)
self.setRowMinimumHeight(4, 5)
self.addWidget(self.setup_toolbar(), 5, 0)
self.setRowStretch(2, 100)
self.setVerticalSpacing(5)
self.setContentsMargins(0, 0, 0, 10) # (L, T, R, B)
def setup_toolbar(self):
"""Setup the toolbar of the widget. """
toolbar = QWidget()
btn_calib = QPushButton('Compute Recharge')
btn_calib.clicked.connect(self.btn_calibrate_isClicked)
self.btn_show_result = QToolButtonSmall(icons.get_icon('search'))
self.btn_show_result.clicked.connect(self.figstack.show)
self.btn_show_result.setToolTip("Show GLUE results.")
self.btn_save_glue = ExportGLUEButton(self.wxdset)
layout = QGridLayout(toolbar)
layout.addWidget(btn_calib, 0, 0)
layout.addWidget(self.btn_show_result, 0, 1)
layout.addWidget(self.btn_save_glue, 0, 2)
layout.setContentsMargins(10, 0, 10, 0) # (L, T, R, B)
return toolbar
def set_wldset(self, wldset):
"""Set the namespace for the water level dataset."""
self.wldset = wldset
self.setEnabled(self.wldset is not None and self.wxdset is not None)
gluedf = None if wldset is None else wldset.get_glue_at(-1)
self._setup_ranges_from_wldset(gluedf)
self.figstack.set_gluedf(gluedf)
self.btn_save_glue.set_model(gluedf)
def set_wxdset(self, wxdset):
"""Set the namespace for the weather dataset."""
self.wxdset = wxdset
self.setEnabled(self.wldset is not None and self.wxdset is not None)
def _setup_ranges_from_wldset(self, gluedf):
"""
Set the parameter range values from the last values that were used
to produce the last GLUE results saved into the project.
"""
if gluedf is not None:
self.QSy_min.setValue(min(gluedf['ranges']['Sy']))
self.QSy_max.setValue(max(gluedf['ranges']['Sy']))
self.CRO_min.setValue(min(gluedf['ranges']['Cro']))
self.CRO_max.setValue(max(gluedf['ranges']['Cro']))
self.QRAS_min.setValue(min(gluedf['ranges']['RASmax']))
self.QRAS_max.setValue(max(gluedf['ranges']['RASmax']))
self._Tmelt.setValue(gluedf['params']['tmelt'])
self._CM.setValue(gluedf['params']['CM'])
self._deltaT.setValue(gluedf['params']['deltat'])
def get_Range(self, name):
if name == 'Sy':
return [self.QSy_min.value(), self.QSy_max.value()]
elif name == 'RASmax':
return [self.QRAS_min.value(), self.QRAS_max.value()]
elif name == 'Cro':
return [self.CRO_min.value(), self.CRO_max.value()]
else:
raise ValueError('Name must be either Sy, Rasmax or Cro.')
@property
def Tmelt(self):
return self._Tmelt.value()
@property
def CM(self):
return self._CM.value()
@property
def deltaT(self):
return self._deltaT.value()
def btn_calibrate_isClicked(self):
"""
Handles when the button to compute recharge and its uncertainty is
clicked.
"""
self.start_glue_calcul()
def start_glue_calcul(self):
"""
Start the method to evaluate ground-water recharge and its
uncertainty.
"""
# Set the parameter ranges.
self.rechg_worker.Sy = self.get_Range('Sy')
self.rechg_worker.Cro = self.get_Range('Cro')
self.rechg_worker.RASmax = self.get_Range('RASmax')
self.rechg_worker.TMELT = self.Tmelt
self.rechg_worker.CM = self.CM
self.rechg_worker.deltat = self.deltaT
# Set the data and check for errors.
error = self.rechg_worker.load_data(self.wxdset, self.wldset)
if error is not None:
QMessageBox.warning(self, 'Warning', error, QMessageBox.Ok)
return
# Start the computation of groundwater recharge.
self.progressbar.show()
waittime = 0
while self.rechg_thread.isRunning():
time.sleep(0.1)
waittime += 0.1
if waittime > 15:
print('Impossible to quit the thread.')
return
self.rechg_thread.start()
def receive_glue_calcul(self, glue_dataframe):
"""
Handle the plotting of the results once ground-water recharge has
been evaluated.
"""
self.rechg_thread.quit()
self.progressbar.hide()
if glue_dataframe is None:
msg = ("Recharge evaluation was not possible because all"
" the models produced were deemed non-behavioural."
"\n\n"
"This usually happens when the range of values for"
" Sy, RASmax, and Cro are too restrictive or when the"
" Master Recession Curve (MRC) does not represent well the"
" behaviour of the observed hydrograph.")
QMessageBox.warning(self, 'Warning', msg, QMessageBox.Ok)
else:
self.wldset.clear_glue()
self.wldset.save_glue(glue_dataframe)
self.sig_new_gluedf.emit(glue_dataframe)
self.btn_save_glue.set_model(glue_dataframe)
self.figstack.set_gluedf(glue_dataframe)
def __init__(self):
super().__init__()
self.dev = None
self.progress_signal.connect(self._on_progress)
self.complete_signal.connect(self._on_complete)
self.error_signal.connect(self._on_error)
lbl_warning = QLabel(
"<font color='red'><b>Make sure jumploader is installed before you flash QMK</b></font>"
)
lbl_warning.setWordWrap(True)
btn_flash_qmk = QPushButton("Flash QMK...")
btn_flash_qmk.clicked.connect(self.on_click_flash_qmk)
lbl_help = QLabel(
"After jumploader is installed, hold Backspace while plugging in the keyboard to start in bootloader mode."
)
lbl_help.setWordWrap(True)
btn_reboot_bl = QPushButton("Reboot to Bootloader")
btn_reboot_bl.clicked.connect(self.on_click_reboot)
btn_flash_jumploader = QPushButton("Flash Jumploader")
btn_flash_jumploader.clicked.connect(self.on_click_flash_jumploader)
btn_restore_stock = QPushButton("Revert to Stock Firmware")
btn_restore_stock.clicked.connect(self.on_click_revert)
self.progress = QProgressBar()
self.progress.setRange(0, 100)
self.progress_label = QLabel("Ready")
self.combobox_devices = QComboBox()
btn_refresh_devices = QToolButton()
btn_refresh_devices.setToolButtonStyle(Qt.ToolButtonTextOnly)
btn_refresh_devices.setText("Refresh")
btn_refresh_devices.clicked.connect(self.on_click_refresh)
devices_layout = QHBoxLayout()
devices_layout.addWidget(self.combobox_devices)
devices_layout.addWidget(btn_refresh_devices)
layout_qmk = QVBoxLayout()
layout_qmk.setAlignment(Qt.AlignTop)
layout_qmk.addWidget(lbl_warning)
layout_qmk.addWidget(btn_flash_qmk)
layout_qmk.addWidget(lbl_help)
layout_stock = QVBoxLayout()
layout_stock.setAlignment(Qt.AlignTop)
layout_stock.addWidget(btn_reboot_bl)
layout_stock.addWidget(btn_flash_jumploader)
layout_stock.addWidget(btn_restore_stock)
layout_progress = QVBoxLayout()
layout_progress.addWidget(self.progress_label)
layout_progress.addWidget(self.progress)
group_qmk = QGroupBox("QMK")
group_qmk.setLayout(layout_qmk)
group_stock = QGroupBox("Stock")
group_stock.setLayout(layout_stock)
group_progress = QGroupBox("")
group_progress.setLayout(layout_progress)
group_layout = QHBoxLayout()
group_layout.addWidget(group_qmk)
group_layout.addWidget(group_stock)
layout = QVBoxLayout()
layout.addLayout(devices_layout, stretch=0)
layout.addLayout(group_layout, stretch=1)
layout.addWidget(group_progress, stretch=0)
self.setLayout(layout)
self.lockable = [
btn_flash_qmk, btn_reboot_bl, btn_flash_jumploader,
btn_restore_stock, self.combobox_devices, btn_refresh_devices
]
self.on_click_refresh()
class Fifteen(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle('Fifteen')
self.setGeometry(400, 250, 600, 600)
self.r_list = [[], [], [], []]
self.moves = 0
self.num_board = []
self.solved = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12],
[13, 14, 15, ' ']]
self.board1 = []
self.value = 0
self.win = False
self.win2 = False
self.wincounter = 0
self.scramble()
self.progress = QProgressBar(self)
self.progress.setGeometry(250, 25, 100, 20)
self.progress.setMaximum(16)
self.progress.setTextVisible(False)
self.progress.setAlignment(Qt.AlignRight)
self.progress.setValue(self.value)
self.percent = QLabel(str(self.progress.value() // 16) + "%", self)
self.percent.setGeometry(360, 25, 100, 20)
self.show()
def scramble(self):
"""
Scrambles the board and checks if it's solvable. If not,
it scrambles it again.
:return: None
"""
possible = False
while not possible:
self.board1 = [i for i in range(1, 16)] + [' '] # 1D List
blank_spot = self.board1.index(' ')
shuffle(self.board1)
n = 4
self.num_board = [
self.board1[i:i + n] for i in range(0, len(self.board1), n)
] # 2D version of the grid's list
og_blank_spot = blank_spot
self.board1.remove(' ')
for i in self.num_board:
if ' ' in i:
blank_spot = 4 - self.num_board.index(i)
inv = 0 # number of inversions
for i in self.board1:
for j in self.board1[self.board1.index(i):]:
if i > j:
inv += 1
self.board1.insert(og_blank_spot, ' ')
if blank_spot % 2 == 0 and inv % 2 != 0 or blank_spot % 2 != 0 and inv % 2 == 0:
possible = True
def paintEvent(self, event):
qp = QPainter()
grid_pen = QPen(Qt.black, 7)
grid_brush = QBrush(QColor(56, 182, 199), Qt.SolidPattern)
qp.begin(self)
qp.setPen(grid_pen)
qp.setBrush(grid_brush)
if not self.win:
for i in range(4):
for j in range(4):
x = (i * 125) + 50
y = (j * 125) + 50
q = QRect(QPoint(x, y), QSize(125, 125))
self.r_list[i].append(q)
qp.setFont(QFont("arial", 20))
qp.drawText(50, 580, "Moves: " + str(self.moves))
for i in range(len(self.r_list)):
for j in range(4):
qp.drawRect(self.r_list[i][j])
qp.drawText(self.r_list[i][j], Qt.AlignCenter,
str(self.num_board[j][i]))
if self.value == 16:
self.win = True
if self.win:
self.progress.hide()
self.percent.hide()
qp.setPen(QPen(QColor(29, 121, 171), 5))
qp.setFont(QFont("Trebuchet MS", 95))
qp.drawText(35, 160, "You Win!")
qp.setPen(QPen(QColor(25, 150, 17), 5))
qp.setFont(QFont("Trebuchet MS", 40))
qp.drawText(20, 350, "Click the screen")
qp.drawText(25, 400, "to restart the game!")
self.win2 = True
qp.end()
def mousePressEvent(self, event):
blank_pos = None
x = event.x()
y = event.y()
row = (y - 50) // 125
col = (x - 50) // 125
mCoord = (row, col) # The exact square which is clicked
if not self.win:
for r in self.num_board:
for n in r:
if n == ' ':
blank_pos = (self.num_board.index(r), r.index(n)
) # position of the blank spot
self.move_click(mCoord, blank_pos, self.num_board)
completed_nums = []
for n1 in range(len(self.num_board)):
for n2 in range(4):
if self.num_board[n1][n2] == self.solved[n1][
n2] and self.num_board[n1][
n2] not in completed_nums:
completed_nums.append(self.solved[n1][n2])
self.value = len(completed_nums)
self.progress.setValue(self.value)
self.percent.setText(str(self.value / 16 * 100) + "%")
self.update()
if self.win2:
self.wincounter += 1
if self.wincounter == 2:
if 0 <= event.x() <= 600 and 0 <= event.y() <= 600:
os.execl(sys.executable, sys.executable, *sys.argv)
def move_click(self, mouse, blank, board):
"""
Sees how far away the mouse click is from the blank, and move the numbers accordingly.
:param mouse: Coordinates of the mouse click on the grid, tuple
:param blank: Coordinates of the blank spot on the grid, tuple
:param board: 2D list of all the numbers on screen, list
:return: None
"""
if 0 <= mouse[0] <= 3 and 0 <= mouse[1] <= 3:
if mouse[0] == blank[0] and mouse[1] != blank[1]: # Checks rows
distance = mouse[1] - blank[1]
d = abs(distance)
if d == 1:
clicked_num = board[mouse[0]][mouse[1]]
board[blank[0]][blank[1]] = clicked_num
board[mouse[0]][mouse[1]] = ' '
self.moves += 1
elif distance == -2:
board[mouse[0]][mouse[1] + d] = board[mouse[0]][mouse[1] +
d - 1]
board[mouse[0]][mouse[1] + d -
1] = board[mouse[0]][mouse[1]]
board[mouse[0]][mouse[1]] = ' '
self.moves += d
elif distance == -3:
closest_num = board[mouse[0]][mouse[1] + d - 1]
second_num = board[mouse[0]][mouse[1] + d - 2]
board[blank[0]][blank[1]] = closest_num
board[mouse[0]][mouse[1] + d - 1] = second_num
board[mouse[0]][mouse[1] + d -
2] = board[mouse[0]][mouse[1]]
board[mouse[0]][mouse[1]] = ' '
elif distance == 2:
board[mouse[0]][mouse[1] -
distance] = board[mouse[0]][mouse[1] -
distance + 1]
board[mouse[0]][mouse[1] - distance +
1] = board[mouse[0]][mouse[1]]
board[mouse[0]][mouse[1]] = ' '
elif distance == 3:
closest_num = board[mouse[0]][mouse[1] - distance + 1]
second_num = board[mouse[0]][mouse[1] - distance + 2]
board[blank[0]][blank[1]] = closest_num
board[mouse[0]][mouse[1] - distance + 1] = second_num
board[mouse[0]][mouse[1] - distance +
2] = board[mouse[0]][mouse[1]]
board[mouse[0]][mouse[1]] = ' '
if mouse[1] == blank[1] and mouse[0] != blank[0]: # Checks columns
distance = mouse[0] - blank[0]
if abs(distance) == 1:
clicked_num = board[mouse[0]][blank[1]]
board[blank[0]][blank[1]] = clicked_num
board[mouse[0]][mouse[1]] = ' '
self.moves += 1
elif distance == -2:
d = abs(distance)
board[mouse[0] + d][mouse[1]] = board[mouse[0] + d -
1][mouse[1]]
board[mouse[0] + d - 1][mouse[1]] = board[mouse[0] + d -
2][mouse[1]]
board[mouse[0] + d - 2][mouse[1]] = ' '
self.moves += d
elif distance == -3:
d = abs(distance)
closest_num = board[mouse[0] + d - 1][mouse[1]]
second_num = board[mouse[0] + d - 2][mouse[1]]
board[blank[0]][blank[1]] = closest_num
board[mouse[0] + d - 1][mouse[1]] = second_num
board[mouse[0] + d - 2][mouse[1]] = board[mouse[0] + d -
3][mouse[1]]
board[mouse[0]][mouse[1]] = ' '
self.moves += d
elif distance == 2:
board[mouse[0] -
distance][mouse[1]] = board[mouse[0] - distance +
1][mouse[1]]
board[mouse[0] - distance +
1][mouse[1]] = board[mouse[0] - distance +
2][mouse[1]]
board[mouse[0] - distance + 2][mouse[1]] = ' '
self.moves += distance
elif distance == 3:
closest_num = board[mouse[0] - distance + 1][mouse[1]]
second_num = board[mouse[0] - distance + 2][mouse[1]]
board[blank[0]][blank[1]] = closest_num
board[mouse[0] - distance + 1][mouse[1]] = second_num
board[mouse[0] - distance +
2][mouse[1]] = board[mouse[0] - distance +
3][mouse[1]]
board[mouse[0]][mouse[1]] = ' '
self.moves += distance
class WSPRUI(QWidget):
def __init__(self, configFile):
super(WSPRUI, self).__init__()
#Things that we need to keep track of to update
self.wsprDevice = WSPRInterfaceObject(configFile)
self.bandCheckboxes = []
self.CurrentGPSStatus = QProgressBar(self)
self.gpsTime = QLabel("00:00:00")
self.gpsPosition = QLabel("0000")
self.gpsPower = QLabel("0")
self.outputFreq = QLabel(self.formatFrequency("0"))
self.setFrequencyValueLable = QLineEdit(self.formatFrequency("0"))
self.dialFrequency = QDial()
self.gpsLocked = QLabel("GPS Signal Quality:")
self.portConnectionIcon = QLabel()
self.portConnectionIcon.setFixedSize(50, 50)
self.portConnectionIcon.mousePressEvent = self.handleConnectionIconClick
self.txtCallsign = QLineEdit()
self.portConnectionLabel = QLabel(self.wsprDevice.config.notconnectedtext)
self.rdoStartUpSignalGen = QRadioButton("Signal Generator")
self.rdoStartUpWSPRBeacon = QRadioButton("WSPR Beacon")
self.rdoStartUpIdle = QRadioButton("Idle")
self.pauseAfterTransmission = QLineEdit("120")
self.manualLocationSetting = QLineEdit("FN44")
self.useManualLocation = QCheckBox()
self.chkCurrentSignalGen = QCheckBox("Signal Generator")
self.chkCurrentWSPRBeacon = QCheckBox("WSPR Beacon")
self.valCurrentMode = QLabel("")
self.transmitStatus = QLabel("")
self.buttonReload = QPushButton("Reload")
self.buttonReload.setFixedSize(100, 50)
self.buttonReload.clicked.connect(self.handleReloadPush)
self.buttonReload.setVisible(self.wsprDevice.config.debug)
self.buttonSave = QPushButton("Save")
self.buttonChangeCurrentMode = QPushButton("Start")
self.debugSection = QGroupBox("Info")
self.textArea = QPlainTextEdit()
self.textArea.setMaximumBlockCount(self.wsprDevice.config.debugAreaMaximumBlockCount)
self.textArea.setReadOnly(True)
self.commandArray = [Command.CALLSIGN,
Command.BANDS,
Command.STARTUP_MODE,
Command.CURRENT_MODE,
Command.POWER,
Command.GENERATOR_FREQUENCY]
self.factorySettingsArray = [Command.FACTORY_FREQUENCY_REFERENCE_OSCILLATOR_FREQUENCY,
Command.FACTORY_HARDWARE_REVISION,
Command.FACTORY_HARDWARE_VERSION,
Command.FACTORY_LOWPASS_FINTER_INSTALLED,
Command.FACTORY_PRODUCT_NUMBER,
Command.FACTORY_SOFTWARE_REVISION,
Command.FACTORY_SOFTWARE_VERSION]
#Create the UI
self.initUI()
#Threads
self.createThreads()
#####################################
#Start - Build All section of the UI
#####################################
#Add all the sections to the main window
def initUI(self):
windowLayout = QGridLayout()
#First Column
#serial port section
serialPort = self.initSerialPortFrame()
windowLayout.addWidget(serialPort, 0, 0)
#Bands Section
bands = self.initBandsFrame()
windowLayout.addWidget(bands, 1, 0, 2, 1)
#Button Section
button = self.initButtonFrame()
windowLayout.addWidget(button, 3, 0)
#Second Column
#info section
callsign = self.initCallsignFrame()
windowLayout.addWidget(callsign, 0, 1)
#Current Status
current = self.initCurrentStatus()
windowLayout.addWidget(current, 1, 1)
#setCurrentStatus Area
setCurrent = self.initSetCurrentStatus()
windowLayout.addWidget(setCurrent, 2, 1)
#Startup Config
startup = self.initStartupModeFrame()
windowLayout.addWidget(startup, 3, 1)
#Third Column
#Debug Area
debug = self.initDebugSection()
windowLayout.addWidget(debug, 0, 2, 4, 1)
#Set the layout and window
self.setLayout(windowLayout)
self.move(300, 150)
self.setWindowTitle(self.wsprDevice.config.name + " " + self.wsprDevice.config.version)
self.show()
#Build section with port information
def initSerialPortFrame(self):
sectionBox = QGroupBox("Serial Port")
tempLayout = QGridLayout()
self.setConnectionStatus()
tempLayout.addWidget(self.portConnectionIcon,0,0)
tempLayout.addWidget(self.portConnectionLabel, 1, 0)
tempLayout.setAlignment(QtCore.Qt.AlignHCenter)
sectionBox.setLayout(tempLayout)
return sectionBox
#create section for Band information
def initBandsFrame(self):
sectionBox = QGroupBox("Bands")
tempLayout = QGridLayout()
i=0
for band in self.wsprDevice.bands:
#for each band make a label and a button
checkbox = QCheckBox(band[1])
tempLayout.addWidget(checkbox, i, 0, 3, 0)
self.bandCheckboxes.append(checkbox)
i+=1
sectionBox.setLayout(tempLayout)
return sectionBox
#Create section for buttons
def initButtonFrame(self):
sectionBox = QGroupBox("Buttons")
sectionBox.setMinimumWidth(250)
tempLayout = QGridLayout()
self.buttonSave.setFixedSize(100, 50)
self.buttonSave.clicked.connect(self.handleSavePush)
tempLayout.addWidget(self.buttonReload, 0, 0)
tempLayout.addWidget(self.buttonSave, 0, 1)
sectionBox.setLayout(tempLayout)
return sectionBox
#create setion for Callsign input
def initCallsignFrame(self):
sectionBox = QGroupBox("Info")
tempLayout = QGridLayout()
self.txtCallsign.setFixedWidth(100)
tempLayout.addWidget(self.txtCallsign, 0, 0, QtCore.Qt.AlignLeft)
lablePauseAfter = QLabel("Pause Time:")
lableSeconds = QLabel("seconds")
self.pauseAfterTransmission.setFixedWidth(75)
tempLayout.addWidget(lablePauseAfter, 1, 0)
tempLayout.addWidget(self.pauseAfterTransmission, 1, 1, QtCore.Qt.AlignLeft)
tempLayout.addWidget(lableSeconds, 1, 2, QtCore.Qt.AlignLeft)
lableLocationSetting = QLabel("Manual Location:")
self.manualLocationSetting.setFixedWidth(75)
tempLayout.addWidget(lableLocationSetting, 2, 0)
tempLayout.addWidget(self.manualLocationSetting, 2, 1, QtCore.Qt.AlignLeft)
tempLayout.addWidget(self.useManualLocation, 2, 2, QtCore.Qt.AlignLeft)
sectionBox.setLayout(tempLayout)
return sectionBox
#Create startup mode frame
def initStartupModeFrame(self):
sectionBox = QGroupBox("Start Up Configuration")
tempLayout = QGridLayout()
#tempLayout.setAlignment(QtCore.Qt.AlignTop)
tempLayout.addWidget(self.rdoStartUpSignalGen, 0, 0, 1, 2)
tempLayout.addWidget(self.rdoStartUpWSPRBeacon, 1, 0, 1, 2)
tempLayout.addWidget(self.rdoStartUpIdle, 2, 0, 1, 2)
sectionBox.setLayout(tempLayout)
return sectionBox
#Create current status section
def initCurrentStatus(self):
sectionBox = QGroupBox("Current Status")
tempLayout = QGridLayout()
#GPS Signal
tempLayout.addWidget(self.gpsLocked, 1, 0, 1, 3)
self.CurrentGPSStatus.setTextVisible(True)
self.CurrentGPSStatus.setValue(0)
tempLayout.addWidget(self.CurrentGPSStatus, 2, 0, 1, 3)
#GPS Time
gpsTimeLabel = QLabel("GPS Time:")
tempLayout.addWidget(gpsTimeLabel, 3, 0)
tempLayout.addWidget(self.gpsTime, 3, 1, 1, 2)
#GPS Position
gpsPositionLabel = QLabel("GPS Position:")
tempLayout.addWidget(gpsPositionLabel, 4, 0)
tempLayout.addWidget(self.gpsPosition, 4, 1, 1, 3)
#Power
gpsPowerLabel = QLabel("Reported Power: ")
tempLayout.addWidget(gpsPowerLabel, 5, 0)
tempLayout.addWidget(self.gpsPower, 5, 1)
gpsdBmLabel = QLabel("dBm")
tempLayout.addWidget(gpsdBmLabel, 5, 2)
#Output Frequency
gpsPowerLabel = QLabel("Output Frequency: ")
tempLayout.addWidget(gpsPowerLabel, 6, 0)
tempLayout.addWidget(self.outputFreq, 6, 1)
gpsdBmLabel = QLabel("Hz")
tempLayout.addWidget(gpsdBmLabel, 6, 2)
lblCurrentMode = QLabel("Current Mode: ")
tempLayout.addWidget(lblCurrentMode, 7, 0)
tempLayout.addWidget(self.valCurrentMode, 7, 1)
self.transmitStatus.setFixedSize(15,15)
self.transmitStatus.setStyleSheet(self.wsprDevice.config.transmitOffStatusCSS)
self.transmitStatus.setToolTip(self.wsprDevice.config.transmitOffStatusToolTip)
tempLayout.addWidget(self.transmitStatus, 7, 2)
#Signal Frequency
tempLayout.setAlignment(QtCore.Qt.AlignTop)
sectionBox.setLayout(tempLayout)
return sectionBox
def initSetCurrentStatus(self):
sectionBox = QGroupBox("Set Mode")
tempLayout = QGridLayout()
#Output Frequency
setFrequencyLabel = QLabel("Output Frequency: ")
tempLayout.addWidget(setFrequencyLabel, 0, 0)
self.setFrequencyValueLable.mousePressEvent = lambda _ : self.setFrequencyValueLable.selectAll()
self.setFrequencyValueLable.setValidator(QtGui.QIntValidator())
self.setFrequencyValueLable.editingFinished.connect(self.frequencyTextComplete)
tempLayout.addWidget(self.setFrequencyValueLable, 0, 1, 1, 2)
gpsdBmLabel = QLabel("Hz")
tempLayout.addWidget(gpsdBmLabel, 0, 3)
self.buttonChangeCurrentMode.clicked.connect(self.handleStartCurrentMode)
self.buttonChangeCurrentMode.setFixedSize(100, 50)
tempLayout.addWidget(self.buttonChangeCurrentMode, 1, 0, 2, 1)
tempLayout.addWidget(self.chkCurrentSignalGen, 1, 2)
tempLayout.addWidget(self.chkCurrentWSPRBeacon, 2, 2)
#TODO: Fix This - Should be able to have either 1 or none, not both
self.chkCurrentSignalGen.stateChanged.connect(self.handleCurrentModeSigGenCheck)
self.chkCurrentWSPRBeacon.stateChanged.connect(self.handleCurrentModeWSPRCheck)
#Signal Frequency
tempLayout.setAlignment(QtCore.Qt.AlignTop)
sectionBox.setLayout(tempLayout)
return sectionBox
def initDebugSection(self):
tempLayout = QGridLayout()
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
self.textArea.setSizePolicy(sizePolicy)
self.textArea.setMinimumWidth(400)
tempLayout.addWidget(self.textArea)
self.debugSection.setLayout(tempLayout)
return self.debugSection
#####################################
#END - Build All section of the UI
#####################################
#####################################
#START - UI Data Changes
#####################################
#Set the connection status based on
#the port information set by the connection process
def setConnectionStatus(self):
connected = self.wsprDevice.port is not None
#print(str(self.wsprDevice.port))
fileName = ""
labelText = ""
if connected:
fileName = self.wsprDevice.config.icons["connected"]
labelText = self.wsprDevice.config.connectedtext + str(self.wsprDevice.port.port)
else:
fileName = self.wsprDevice.config.icons["disconnected"]
labelText = self.wsprDevice.config.notconnectedtext
self.portConnectionLabel.setText(labelText)
pixMap = QtGui.QPixmap(fileName)
self.portConnectionIcon.setPixmap(pixMap)
self.portConnectionIcon.setToolTip(self.wsprDevice.config.icons["toolTip"])
return
#fills all GUI fields with data from the wspr device
def FillData(self):
self.txtCallsign.setText(self.wsprDevice.callsign)
self.gpsPower.setText(self.wsprDevice.power)
#set the band checkboxes
for i, checkbox in enumerate(self.bandCheckboxes):
checkbox.setChecked(self.wsprDevice.bands[i][2] == self.wsprDevice.config.deviceconstants.bandEnabledChar)
#set the startup mode radio buttons
self.rdoStartUpSignalGen.setChecked(self.wsprDevice.startupMode == self.wsprDevice.config.deviceconstants.modeSignalChar)
self.rdoStartUpWSPRBeacon.setChecked(self.wsprDevice.startupMode == self.wsprDevice.config.deviceconstants.modeWSPRChar)
self.rdoStartUpIdle.setChecked(self.wsprDevice.startupMode == self.wsprDevice.config.deviceconstants.modeIdleChar)
return
#clear all GUI fields with data from the wspr device
def ClearData(self):
self.txtCallsign.setText("")
for i, checkbox in enumerate(self.bandCheckboxes):
checkbox.setChecked(False)
self.rdoStartUpSignalGen.setChecked(False)
self.rdoStartUpWSPRBeacon.setChecked(False)
self.rdoStartUpIdle.setChecked(True)
self.valCurrentMode.setText(self.wsprDevice.config.deviceconstants.modeIdleChar)
self.CurrentGPSStatus.setValue(0.0)
self.gpsLocked.setToolTip("Unknown")
self.gpsLocked.setStyleSheet(self.wsprDevice.config.gpsLockedUnknownCSS)
self.gpsTime.setText("00:00:00")
self.gpsPosition.setText("0000")
self.gpsPower.setText("00")
self.outputFreq.setText("0 000 000 000.00")
return
#####################################
#END - UI Data Changes
#####################################
#####################################
#START - UI Event Handlers
#####################################
def handleDialChanged(self):
self.setFrequencyValueLable.setText(str(self.formatFrequency(self.dialFrequency.value())))
def handleConnectionIconClick(self, arg2 = None):
self.wsprDevice.config.debug = not self.wsprDevice.config.debug
self.buttonReload.setVisible(self.wsprDevice.config.debug)
if self.wsprDevice.config.debug:
self.debugSection.setTitle("Debug")
else:
self.debugSection.setTitle("Data")
return
def handleReloadPush(self):
if self.wsprDevice.port is not None:
self.deviceCommunicationThread.sendCommand(CommandType.GET, self.commandArray)
return
def handleSavePush(self):
if self.wsprDevice.port is not None:
commands = [Command.STARTUP_MODE, Command.CALLSIGN]
startUpModeValue = ""
if self.rdoStartUpIdle.isChecked():
startUpModeValue = self.wsprDevice.config.deviceconstants.modeIdleChar
if self.rdoStartUpSignalGen.isChecked():
startUpModeValue = self.wsprDevice.config.deviceconstants.modeSignalChar
if self.rdoStartUpWSPRBeacon.isChecked():
startUpModeValue = self.wsprDevice.config.deviceconstants.modeWSPRChar
values = [startUpModeValue, self.txtCallsign.text()]
for i, checkbox in enumerate(self.bandCheckboxes):
valueToSend = ""
commands.append(Command.BANDS)
if checkbox.isChecked():
checkboxValue = self.wsprDevice.config.deviceconstants.bandEnabledChar
else:
checkboxValue = self.wsprDevice.config.deviceconstants.bandDisabledChar
#set the bands on the device object
self.wsprDevice.bands[i][2] = checkboxValue
valueToSend = str(i).zfill(2) + " " + checkboxValue
values.append(valueToSend)
#location stuff
commands.append(Command.LOCATION_STATE)
if self.useManualLocation.isChecked:
values.append(self.wsprDevice.config.deviceconstants.locationStateManual)
commands.append(Command.LOCATION_VALUE)
values.append(self.manualLocationSetting.text())
else:
values.append(self.wsprDevice.config.deviceconstants.locationStateGPS)
self.deviceCommunicationThread.sendCommand(CommandType.SET, commands, values)
#after saving update the device object to have the saved values
self.wsprDevice.callsign = self.txtCallsign.text()
self.wsprDevice.startupMode = startUpModeValue
return
def handleCurrentModeWSPRCheck(self):
#TODO: Fix This
if self.chkCurrentWSPRBeacon.isChecked:
self.chkCurrentSignalGen.setChecked(False)
return
def handleCurrentModeSigGenCheck(self):
#TODO: Fix This
if self.chkCurrentSignalGen.isChecked:
self.chkCurrentWSPRBeacon.setChecked(False)
return
def handleStartCurrentMode(self):
if self.wsprDevice.port is not None:
commands = []
values = []
if self.buttonChangeCurrentMode.text() == "Start":
if self.chkCurrentSignalGen.isChecked():
originalFreq = self.setFrequencyValueLable.text()
rawFrequency = self.formatFrequency(originalFreq).replace(",", "").replace(".", "")
#save Frequency and mode to signal gen
commands = [Command.GENERATOR_FREQUENCY, Command.CURRENT_MODE]
values = [rawFrequency, self.wsprDevice.config.deviceconstants.modeSignalChar]
elif self.chkCurrentWSPRBeacon.isChecked():
#save mode to WSPR
commands = [Command.GENERATOR_FREQUENCY, Command.CURRENT_MODE]
values = [rawFrequency, self.wsprDevice.config.deviceconstants.modeWSPRChar]
else:
#save Mode to Idle
commands = [Command.CURRENT_MODE]
values = [self.wsprDevice.config.deviceconstants.modeIdleChar]
else:
#save Mode to Idle
commands = [Command.CURRENT_MODE]
values = [self.wsprDevice.config.deviceconstants.modeIdleChar]
self.deviceCommunicationThread.sendCommand(CommandType.SET, commands, values)
self.deviceCommunicationThread.sendCommand(CommandType.GET, [Command.GENERATOR_FREQUENCY, Command.CURRENT_MODE])
return
#####################################
#END - UI Event Handlers
#####################################
#####################################
#START - Thread Callbacks
#####################################
def callbackDetecionChange(self, portName):
self.textArea.appendPlainText("Connected To Port: " + portName)
self.autoDetecThread.pause()
self.setConnectionStatus()
self.deviceCommunicationThread.start()
self.deviceCommunicationThread.sendCommand(CommandType.GET, self.factorySettingsArray + self.commandArray)
return
def callbackDeviceRead(self, readText):
self.textArea.appendPlainText(readText)
return
def callbackDeviceFill(self, responce):
request = responce.split(",")
if request[0] == self.wsprDevice.config.deviceconstants.commands.responce.callsign:
self.wsprDevice.callsign = request[1]
elif request[0] == self.wsprDevice.config.deviceconstants.commands.responce.startupmode:
self.wsprDevice.startupMode = request[1]
elif request[0] == self.wsprDevice.config.deviceconstants.commands.responce.power:
self.wsprDevice.power = request[1]
self.FillData()
def callbackDeviceRealTime(self, responce):
request = responce.split(",")
if request[0] == self.wsprDevice.config.deviceconstants.commands.responce.gpssatdata:
self.CurrentGPSStatus.setValue(float(request[1]))
elif request[0] == self.wsprDevice.config.deviceconstants.commands.responce.gpsposition:
self.gpsPosition.setText(request[1])
elif request[0] == self.wsprDevice.config.deviceconstants.commands.responce.gpstime:
self.gpsTime.setText(request[1])
elif request[0] == self.wsprDevice.config.deviceconstants.commands.responce.gpslocked:
if request[1] == self.wsprDevice.config.deviceconstants.commands.deviceTrue:
self.gpsLocked.setStyleSheet(self.wsprDevice.config.gpsLockedTrueCSS)
self.gpsLocked.setToolTip("GPS Locked")
else:
self.gpsLocked.setStyleSheet(self.wsprDevice.config.gpsLockedFalseCSS)
self.gpsLocked.setToolTip("...Searching...")
elif request[0] == self.wsprDevice.config.deviceconstants.commands.responce.generatorfrequency:
self.wsprDevice.generatorfrequency = request[1]
self.displayCurrentModeValues()
elif request[0] == self.wsprDevice.config.deviceconstants.commands.responce.transmitting:
self.wsprDevice.transmitStatus = request[1]
self.displayCurrentModeValues()
elif request[0] == self.wsprDevice.config.deviceconstants.commands.responce.currentmode:
self.wsprDevice.currentMode = request[1]
self.displayCurrentModeValues()
def callbackThreadException(self, error):
#self.textArea.appendPlainText("EXCEPTION IN THREAD!")
self.textArea.appendPlainText(error)
self.deviceCommunicationThread.pause()
self.wsprDevice.port = None
self.setConnectionStatus()
self.autoDetecThread.resume()
self.ClearData()
#####################################
#END - Thread Callbacks
#####################################
#####################################
#START - Thread handlers
#####################################
def createThreads(self):
#detect the wspr device
self.autoDetecThread = AutoDetectionThread(self.wsprDevice)
self.autoDetecThread.port.connect(self.callbackDetecionChange)
self.autoDetecThread.read.connect(self.callbackDeviceRead)
self.autoDetecThread.start()
#Communicate with wspr device
self.deviceCommunicationThread = DeviceCommunicationThread(self.wsprDevice)
self.deviceCommunicationThread.display.connect(self.callbackDeviceRead)
self.deviceCommunicationThread.update.connect(self.callbackDeviceFill)
self.deviceCommunicationThread.realtime.connect(self.callbackDeviceRealTime)
self.deviceCommunicationThread.exception.connect(self.callbackThreadException)
def stopThreads(self):
self.autoDetecThread.stop()
self.deviceCommunicationThread.stop()
self.autoDetecThread.wait()
self.deviceCommunicationThread.wait()
def pauseThreads(self):
self.autoDetecThread.pause()
self.deviceCommunicationThread.pause()
#catches the close of the application
#clears up threads before closing
def closeEvent(self, event):
self.stopThreads()
return
#####################################
#END - Thread handlers
#####################################
#####################################
#START - Helper Functions
#####################################
def displayCurrentModeValues(self):
formattedFreq = self.formatFrequency(0)
#If we have a frequency get it
if self.wsprDevice.generatorfrequency is not None:
formattedFreq = self.formatFrequency(self.wsprDevice.generatorfrequency)
if self.wsprDevice.transmitStatus == self.wsprDevice.config.deviceconstants.commands.deviceTrue:
#if we are transmitting
self.transmitStatus.setStyleSheet(self.wsprDevice.config.transmitOnStatusCSS)
self.transmitStatus.setToolTip(self.wsprDevice.config.transmitOnStatusToolTip)
self.outputFreq.setText(formattedFreq)
#if we are transmitting make the start button a stop button
self.buttonChangeCurrentMode.setText("Stop")
else:
#Not transmitting
self.transmitStatus.setStyleSheet(self.wsprDevice.config.transmitOffStatusCSS)
self.transmitStatus.setToolTip(self.wsprDevice.config.transmitOffStatusToolTip)
self.outputFreq.setText(formattedFreq)
#not transmitting we should make the stop button back to a start button
self.buttonChangeCurrentMode.setText("Start")
#depending on the mode we should check or uncheck the set mode checkboxes
self.chkCurrentSignalGen.setChecked(self.wsprDevice.currentMode == self.wsprDevice.config.deviceconstants.modeSignalChar)
self.chkCurrentWSPRBeacon.setChecked(self.wsprDevice.currentMode == self.wsprDevice.config.deviceconstants.modeWSPRChar)
#Set the current mode description
currentModeDescription = ""
if self.wsprDevice.currentMode == self.wsprDevice.config.deviceconstants.modeSignalChar:
currentModeDescription = self.wsprDevice.config.deviceconstants.modeSignalDescription
elif self.wsprDevice.currentMode == self.wsprDevice.config.deviceconstants.modeWSPRChar:
currentModeDescription = self.wsprDevice.config.deviceconstants.modeWSPRDescription
elif self.wsprDevice.currentMode == self.wsprDevice.config.deviceconstants.modeIdleChar:
currentModeDescription = self.wsprDevice.config.deviceconstants.modeIdleDescription
self.valCurrentMode.setText(currentModeDescription)
#only set the set frequency if it has not been set
if self.setFrequencyValueLable.text() == self.formatFrequency(0):
self.setFrequencyValueLable.setText(formattedFreq)
def formatFrequency(self, orig_frequency):
frequency = str(orig_frequency).replace(",", "").replace(".", "").zfill(12)
gHz = frequency[0:1]
decimals = frequency[10:12]
mainDigits = frequency[1:10]
formattedFreq = gHz + "," + ','.join([mainDigits[i:i+3] for i in range(0, len(mainDigits), 3)]) + "." + decimals
return formattedFreq
def frequencyTextComplete(self):
origVal = self.setFrequencyValueLable.text()
newVal = origVal.replace(",", "").replace(".", "")
self.setFrequencyValueLable.setText(self.formatFrequency(newVal))
#####################################
#END - Helper Functions
#####################################
class MainWindow(QWidget):
"""
Simple dialog that consists of a Progress Bar and a Button.
Clicking on the button results in the start of a timer and
updates the progress bar.
"""
start_flag = 1
def __init__(self):
QWidget.__init__(self)
self.setStyleSheet("color: black; background-color: rgb(0,162,232);")
self.setGeometry(60,80,500,600)
self.setWindowTitle('Watching SVC Files FOR TYPE3-ABC')
#button
self.button = QPushButton('Start', self)
self.button.setStyleSheet("color: black; font-size : 23px; border : 3px solid black")
self.button.setGeometry(40, 30, 130, 40)
self.button.clicked.connect(self.onButtonClick)
#progressbar
self.progress = QProgressBar(self)
self.progress.setGeometry(40, 100, 420, 15)
self.progress.setMaximum(ENV.CYCLE_TIME)
#List label
list_label = QLabel(self)
list_label.setStyleSheet("color: black; font-size : 23px;")
list_label.setText("PRINTING LOG")
list_label.setGeometry(60, 160, 200, 30)
#listbox
self.listwidget = QListWidget(self)
self.listwidget.setStyleSheet("color: black; border : 3px solid black; font-size : 16px")
self.listwidget.setGeometry(40, 200, 420, 300)
self.time_label = QLabel(self)
self.time_label.setStyleSheet("color: black; font-size : 20px; border : 3px solid black")
self.time_label.setText("")
self.time_label.setGeometry(40, 520, 300, 30)
timer = QTimer(self)
timer.timeout.connect(self.showTime)
timer.start(1000)
self.show()
self.start_flag = 1
def onButtonClick(self):
if self.start_flag == 0 :
print ("It started already")
return
self.start_flag = 0
print (self.start_flag)
try:
with open(ENV.MASTERFILEPATH + ENV.TYPE3_PRINT):
os.remove(ENV.MASTERFILEPATH + ENV.TYPE3_PRINT)
print ("Old TYPE3.csv file will be removed and create a new one.")
except IOError:
print ("New TYPE3.csv file will be created")
try:
with open(ENV.MASTERFILEPATH + "Type3_info.csv"):
os.remove(ENV.MASTERFILEPATH + "Type3_info.csv")
print ("Old TYPE3_info.csv file will be removed and create a new one.")
except IOError:
print ("New TYPE3_info.csv file will be created")
#for type3 processes
print ("======================================OPENING MASTERSHEET EXCEL FILES================================")
print ("-------------------------------------- TYPE3 MASTERSHEET ------------------------------------")
#read the master sheet file for each csv files
mastersheet = pd.read_excel (ENV.MASTERFILEPATH + ENV.TYPE3_MASTER_FILENAME)
records = mastersheet.to_records()
groupmastersheet = pd.read_excel(ENV.MASTERFILEPATH + ENV.GROUP_TYPE3_MASTER_FILENAME)
group_cnt = len(groupmastersheet.columns)
key_values = list(groupmastersheet.keys())
if key_values[-1] == "SKIP n/a" :
group_cnt -= 1
self.type3_Run = []
for x in range(0,group_cnt) :
groupmastersheet = pd.read_excel(ENV.MASTERFILEPATH + ENV.GROUP_TYPE3_MASTER_FILENAME, usecols = [x])
group_temp = groupmastersheet.to_records()
#run new process for new group
run_index = len(self.type3_Run)
self.type3_Run.append(TYPE3_LOGIC_THREAD.External())
self.type3_Run[run_index].files = []
index = 0
while 1 :
if type(group_temp[index][1]) == float:
break
#new file object created
#read file name
self.type3_Run[run_index].files.append(group_temp[index][1])
index += 1
index += 1
#for triggering B of TVA condition
self.type3_Run[run_index].Enter_B_INDEX_need = int(group_temp[index][1].replace("B: All Asset Index 4/5 = ", "").replace(" > + Total TVA Sum is Positive All Assets.", ""))
index += 1
#for triggering S of TVA condition
self.type3_Run[run_index].Print_C_IN_B_INDEX = int(group_temp[index][1].replace("C: All Asset Index 4/5 = < ", ""))
index += 2
#for printing C in B of TVA condition
self.type3_Run[run_index].Enter_S_INDEX_need = int(group_temp[index][1].replace("S: All Asset Index 2/3 = ", "").replace(" > + Total TVA Sum is Negative All Assets.", ""))
index += 1
#for printing C in S of TVA condition
self.type3_Run[run_index].Print_C_IN_S_INDEX = int(group_temp[index][1].replace("C: All Asset Index 2/3 = < ", ""))
index += 2
#for starting time for this group
self.type3_Run[run_index].start_hour = int(group_temp[index][1].replace("Start : ", ""))
index += 1
#for ending time for this group
self.type3_Run[run_index].end_hour = int(group_temp[index][1].replace("End : ", ""))
index += 2
if len(group_temp) > index and group_temp[index][1] == "OPPOSITE" :
self.type3_Run[run_index].opposite = group_temp[index + 1][1]
self.type3_Run[run_index].countChanged.connect(self.onCountChanged)
self.type3_Run[run_index].printChanged.connect(self.onPrintChanged)
self.type3_Run[run_index].start()
def onCountChanged(self, value):
self.progress.setValue(value)
def onPrintChanged(self, value) :
self.listwidget.addItems([value])
def showTime(self) :
format = "%H:%M:%S"
# Current time in UTC
now_gmt = datetime.now(timezone('GMT'))
gmt_time = now_gmt.astimezone(timezone('Europe/Moscow'))
self.time_label.setText("GMT+3 " + gmt_time.strftime(format))
class Dialog(QDialog, Ui_Dialog):
sendUser = pyqtSignal(object)
sendCreated = pyqtSignal(object)
def __init__(self, app, parent=None):
super(Dialog, self).__init__(parent)
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.setWindowTitle("Process Video")
self.dir = os.path.dirname(os.path.realpath(__file__))
self.created = {}
self.user = None
self.thread = None
self.progressBar = None
self.progressAllBar = None
self.progressLabel = None
self.img_exist = False
self.params_dict = None
self.of_exist = False
self.back_of_exist = False
self.depth_exist = False
self.gt_exist = False
self.create_super_pixel_label = False
self.no_error = True
self.object_detection_dir_exist = False
self.vid_name = None
self.all_run = 1
self.run_count = 1
self.fps = 30
self.fps_limit = 60
self.low = 0.0
self.high = 1.0
self.run_dict = {}
self.super_pixel_method = ""
self.app = app
self.ui.b_info.setIconSize(QSize(50, 50))
self.ui.b_info.setIcon(QApplication.style().standardIcon(
QStyle.SP_MessageBoxInformation))
homedir = os.path.expanduser("~")
if platform.system() == "Windows":
datadir = os.sep.join([homedir, "Analyser"])
else:
datadir = os.sep.join([homedir, ".analyser"])
if not os.path.exists(datadir):
os.makedirs(datadir)
self.user_file = os.path.join(datadir, ".userInfo.json")
self.signalSetup()
self.loadUser()
self.userSetup()
def signalSetup(self):
"""
Setup for signal connections
"""
self.ui.b_info.clicked.connect(self.showInfo)
self.ui.b_save.clicked.connect(self.openSave)
self.ui.b_vid.clicked.connect(self.openVideo)
self.ui.b_run.clicked.connect(self.startRun)
self.ui.b_colour.clicked.connect(self.pickColour)
self.ui.b_ground_truth.clicked.connect(self.openGroundTruth)
self.ui.t_fps.textChanged.connect(self.changeFps)
self.ui.t_low.editingFinished.connect(self.changeLow)
self.ui.t_high.editingFinished.connect(self.changeHigh)
self.ui.c_error_plot.stateChanged.connect(self.checkFiles)
self.ui.c_speed_plot.stateChanged.connect(self.checkFiles)
self.ui.c_crash_plot.stateChanged.connect(self.checkFiles)
self.ui.combo_superpixel.currentIndexChanged.connect(
self.changeSuperPixelMethod)
self.ui.c_optimize.stateChanged.connect(self.checkFiles)
self.ui.c_draw.stateChanged.connect(self.checkFiles)
self.ui.c_velocity.stateChanged.connect(self.checkFiles)
self.ui.c_object_detection.stateChanged.connect(self.checkFiles)
def showInfo(self):
"""Show information dialog
"""
widget = DialogInfo(app=self.app, parent=self)
widget.exec_()
def changeLow(self):
"""Change the value of the low drop based on the text inside t_low
"""
self.changeLowHigh(self.ui.t_low, t_type="low")
def changeHigh(self):
"""Change the value of the high drop based on the text inside t_high
"""
self.changeLowHigh(self.ui.t_high, t_type="high")
def changeLowHigh(self, text_widget, t_type="low"):
"""Change the value of low/high drop
Arguments:
text_widget {QLineEdit} -- t_low or t_high
Keyword Arguments:
t_type {str} -- which line edit was given (default: {"low"})
"""
check = re.search("(0[.][0-9]+|1)", text_widget.text())
if check and self.ui.t_low.text() != self.ui.t_high.text():
num = check.group()
i_num = float(num)
if t_type == "low":
self.low = i_num
else:
self.high = i_num
text_widget.setText(str(i_num))
else:
logging.info("Wrong Input For low or high")
if t_type == "low":
text_widget.setText("0.0")
self.low = 0.0
else:
text_widget.setText("1")
self.high = 1
def changeSuperPixelMethod(self, index):
"""Change the super pixel method
Arguments:
index {int} -- index of the selected super pixel method
"""
if index == 0:
self.super_pixel_method = ""
elif index == 1:
self.super_pixel_method = "Felzenszwalb"
elif index == 2:
self.super_pixel_method = "Quickshift"
elif index == 3:
self.super_pixel_method = "Slic"
elif index == 4:
self.super_pixel_method = "Watershed"
self.checkFiles()
def openGroundTruth(self):
"""Open file with ground truth values for speed
"""
gt_dir = self.openFile(
self.user["GT"],
title="Load Ground Truth Data",
file_filter="Numpy Files (*.npy)",
)
if gt_dir != "":
self.user["GT"] = gt_dir
self.ui.l_ground_truth.setText("Load: " +
self.splitPath(gt_dir)[-1])
self.checkFiles()
def changeFps(self):
"""
Change fps for the created videos
"""
check = re.search("[1-9][0-9]*", self.ui.t_fps.text())
if check:
num = check.group()
fps = int(num)
if fps > self.fps_limit:
logging.warning(
"Too big number for fps. Falling back to {0} fps.".format(
self.fps_limit))
fps = self.fps_limit
self.fps = fps
self.ui.t_fps.setText(str(fps))
else:
logging.info("Wrong Input For Fps")
self.ui.t_fps.setText("30")
self.fps = 30
def splitPath(self, path):
"""Split the given path based on filesystem
Arguments:
path {str} -- path you want to split
Returns:
path splitted on / or \ -- only uses \ on windows
"""
return os.path.split(path)
def openSave(self):
"""Open directory to save results
"""
save_dir = QFileDialog.getExistingDirectory(self, "Select a folder",
self.user["Save"],
QFileDialog.ShowDirsOnly)
if save_dir != "":
self.user["Save"] = save_dir
name_split = self.splitPath(save_dir)[-1]
name = name_split.split(".")[0]
self.ui.l_save.setText("Save to: " + name)
self.checkFiles()
def checkFiles(self):
"""Checks if there are folders from previous runs, so we don't need to create them.
Also, checks condotions for checkboxes and buttons
"""
if self.user["Save"] != "":
self.of_exist = os.path.exists(
os.path.join(self.user["Save"], "Of"))
self.back_of_exist = os.path.exists(
os.path.join(self.user["Save"], "Back_Of"))
self.img_exist = os.path.exists(
os.path.join(self.user["Save"], "Images"))
self.depth_exist = os.path.exists(
os.path.join(self.user["Save"], "Depth"))
self.object_detection_dir_exist = os.path.exists(
os.path.join(self.user["Save"], "ObjectDetection"))
self.gt_exist = self.user["GT"] != ""
self.create_super_pixel_label = (
self.super_pixel_method != "" and not os.path.exists(
os.path.join(self.savePathJoin("Super_Pixel"),
self.super_pixel_method)))
self.ui.c_crash_plot_video.setEnabled(self.ui.c_crash_plot.isChecked())
self.ui.t_low.setEnabled(not self.ui.c_optimize.isChecked())
self.ui.t_high.setEnabled(not self.ui.c_optimize.isChecked())
self.ui.c_optimize.setEnabled(self.gt_exist)
self.ui.c_error_plot.setEnabled(self.gt_exist)
self.ui.c_error_plot_video.setEnabled(self.ui.c_error_plot.isChecked())
self.ui.c_speed_plot_video.setEnabled(self.ui.c_speed_plot.isChecked())
self.ui.c_super_pixel_video.setEnabled(
self.ui.combo_superpixel.currentIndex() != 0)
self.ui.c_csv.setEnabled(self.ui.c_error_plot.isChecked())
if self.runRequirements():
self.ui.b_run.setEnabled(True)
else:
self.ui.b_run.setEnabled(False)
def runRequirements(self):
"""Basic requirements to start run
Returns:
bool -- returns true if the requirements are satisfied
"""
ready = (self.user["Save"] != ""
and self.user["Video"] != "") or self.img_exist
return ready
def openVideo(self):
"""Open video to analyze
"""
fname = self.openFile(self.user["Video"])
if fname != "":
error_opening_video = False
cam = cv2.VideoCapture(fname)
logging.info("Opening video Check: {0}".format(fname))
currentframe = 0
ret, frame = cam.read()
if ret is False:
error_opening_video = True
# Release all space and windows once done
cam.release()
cv2.destroyAllWindows()
if error_opening_video:
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Error on opening the video: {0}".format(fname))
msg.setWindowTitle("Information")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
else:
self.user["Video"] = fname
name = self.splitPath(fname)[-1]
self.vid_name = name.split(".")[0]
self.ui.l_vid.setText("Load: " + self.vid_name)
self.checkFiles()
def openFile(self,
folder,
title="Open Video",
file_filter="Video Files (*.mp4 *.avi *.mkv)"):
"""Open QFileDialog with the given parameters, returns selected file
Arguments:
folder {str} -- path where the file dialog should start
Keyword Arguments:
title {str} -- title of the file dialog (default: {"Open Video"})
file_filter {str} -- filter for file extensions (default: {"Video Files (*.mp4 *.avi *.mkv)"})
Returns:
str -- path to file
"""
fname = QFileDialog.getOpenFileName(self, title, folder, file_filter)
return fname[0]
def userSetup(self):
"""Label text setup if the user json is not empty
"""
if self.user["Save"] == "":
self.ui.b_run.setEnabled(False)
else:
name_split = self.splitPath(self.user["Save"])[-1]
name = name_split.split(".")[0]
self.ui.l_save.setText("Save to: " + name)
if self.user["GT"] != "":
self.ui.l_ground_truth.setText(
self.splitPath(self.user["GT"])[-1])
self.ui.l_colour.setText(self.user["Colour"])
def loadUser(self):
"""Load user file if exists, create empty otherwise
"""
if os.path.isfile(self.user_file):
logging.info("Found User File")
with open(self.user_file, "r") as json_file:
self.user = json.load(json_file)
self.checkFiles()
else:
self.user = {
"Save": "",
"Of": "",
"Depth": "",
"Video": "",
"Colour": "#1a1a1b",
"GT": "",
}
self.saveUser()
def saveUser(self):
"""Saves user data to json file
"""
self.user["Video"] = ""
with open(self.user_file, "w+") as json_file:
json.dump(self.user, json_file, indent=4)
def errorChecks(self):
"""Check for errors and inform the user in a QMessageBox if found any
Returns:
bool -- if true then the execution stops
"""
stop_calculation = False
found_error = False
errors = {"Info": [], "Critical": []}
error_types = []
ori_images = 0
of_images = 0
depth_images = 0
back_of_images = 0
if os.path.exists(self.savePathJoin("Images")):
ori_images = len(
listDirectory(self.savePathJoin("Images"), extension="png"))
# Check image folder
if self.img_exist and not os.path.exists(self.savePathJoin("Images")):
if os.path.exists(self.user["Video"]):
errors["Info"].append(
"Images folder {0} doesn't exist -> Recreate it and recalculate optical flow and depth estimations"
.format(self.savePathJoin("Images")))
error_types.append("NoImages")
else:
stop_calculation = True
errors["Critical"].append((
"Images folder {0} and video file {1} don't exist -> Stopping run"
.format(self.savePathJoin("Images"), self.user["Video"])))
elif self.img_exist and os.path.exists(self.user["Video"]):
errors["Info"].append(
"Both the video {0} and Images folder {1} exist -> using Images folder by default"
.format(self.user["Video"], self.savePathJoin("Images")))
elif not self.img_exist and not os.path.isfile(self.user["Video"]):
stop_calculation = True
errors["Critical"].append((
"Images folder {0} and video file {1} don't exist -> Stopping run"
.format(self.savePathJoin("Images"), self.user["Video"])))
# Check video file
if self.user["Video"] != "" and not os.path.isfile(self.user["Video"]):
if os.path.exists(self.savePathJoin("Images")):
errors["Info"].append((
"Video file {0} doesn't exist -> Using images in the Images folder instead"
.format(self.user["Video"])))
else:
stop_calculation = True
errors["Critical"].append((
"Images folder {0} and video file {1} don't exist -> Stopping run"
.format(self.savePathJoin("Images"), self.user["Video"])))
elif os.path.isfile(self.user["Video"]) and os.path.exists(
self.savePathJoin("Images")):
pass
# Check optical flow
if self.of_exist and not os.path.exists(self.savePathJoin("Of")):
errors["Info"].append((
"Optical flow folder {0} doesn't exist -> Recalculating optical flow"
.format(self.savePathJoin("Of"))))
error_types.append("NoOf")
elif self.of_exist:
of_images = len(
listDirectory(self.savePathJoin("Of"), extension="png"))
if of_images != ori_images - 1 and ori_images != 0:
errors["Info"].append((
"Optical flow image number {0} doesn't match video image number {1} - 1 -> Recalculating optical flow"
.format(of_images, ori_images)))
error_types.append("NoOf")
# Check backward optical flow
if self.back_of_exist and not os.path.exists(
self.savePathJoin("Back_Of")):
errors["Info"].append((
"Backward optical flow folder {0} doesn't exist -> Recalculating backward optical flow"
.format(self.savePathJoin("Back_Of"))))
error_types.append("NoOf")
elif self.back_of_exist:
back_of_images = len(
listDirectory(self.savePathJoin("Back_Of"), extension="png"))
if back_of_images != of_images:
errors["Info"].append((
"Backward optical flow image number {0} doesn't match optical flow image number {1} -> Recalculating backward optical flow"
.format(back_of_images, of_images)))
error_types.append("NoOf")
# Check depth estimation
if self.depth_exist and not os.path.exists(self.savePathJoin("Depth")):
errors["Info"].append((
"Depth folder {0} doesn't exist -> Recalculating depth".format(
self.savePathJoin("Depth"))))
error_types.append("NoDepth")
elif self.depth_exist:
depth_images = len(
listDirectory(self.savePathJoin("Depth"), extension="png"))
if depth_images != ori_images and ori_images != 0:
errors["Info"].append((
"Depth image number {0} doesn't match video image number {1} -> Recalculating depth"
.format(depth_images, ori_images)))
error_types.append("NoDepth")
# Check ground truth
if self.gt_exist and not os.path.isfile(self.user["GT"]):
errors["Info"].append(
("Ground Truth file {0} doesn't exist -> File won't be used".
format(self.user["GT"])))
error_types.append("NoGT")
# Check super pixel labels
if (self.super_pixel_method != "" and os.path.exists(
os.path.join(self.savePathJoin("Super_Pixel"),
self.super_pixel_method)) and ori_images != 0
and len(
listDirectory(
os.path.join(self.savePathJoin("Super_Pixel"),
self.super_pixel_method),
extension=".npy",
)) != ori_images):
errors["Info"].append((
"Super pixel label number {0} doesn't match image number {1} -> Recalculating super pixel labels"
.format(
len(
listDirectory(
os.path.join(
self.savePathJoin("Super_Pixel"),
self.super_pixel_method,
),
extension=".npy",
)),
ori_images,
)))
error_types.append("LabelError")
# Check object detection
if self.ui.c_object_detection.isChecked() and os.path.exists(
self.savePathJoin("ObjectDetection")):
if (len(
listDirectory(self.savePathJoin("ObjectDetection"),
extension=".png")) != ori_images):
errors["Info"].append(
"Object Detection image number {0} doesn't match image number of video {1} -> Recalculating object detection"
.format(
len(
listDirectory(self.savePathJoin("ObjectDetection"),
extension=".png")),
ori_images,
))
error_types.append("ObDetError")
elif (len(
listDirectory(self.savePathJoin("ObjectDetection"),
extension=".npy")) != ori_images):
errors["Info"].append(
"Object Detection numpy array number {0} doesn't match image number of video {1} -> Recalculating object detection"
.format(
len(
listDirectory(self.savePathJoin("ObjectDetection"),
extension=".npy")),
ori_images,
))
error_types.append("ObDetError")
answer = ""
if len(errors["Info"]) > 0 and len(errors["Critical"]) == 0:
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText(
"Some calculations might not run the way you expect them.\nIn show details check the right side of the arrows to see what will happen."
)
msg.setWindowTitle("Information")
all_info = ""
for info in errors["Info"]:
all_info += info + "\n\n"
msg.setDetailedText(all_info)
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Abort)
answer = msg.exec_()
elif len(errors["Critical"]) > 0:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText(
"Found critical error\nCouldn't start run, see show details for more information"
)
msg.setWindowTitle("Critical Error")
all_info = ""
for info in errors["Critical"]:
all_info += info + "\n"
msg.setDetailedText(all_info)
msg.setStandardButtons(QMessageBox.Abort)
answer = msg.exec_()
if answer != int("0x00040000", 16):
for ty in error_types:
logging.info("Solve error: {0}".format(ty))
if ty == "NoImage":
self.img_exist = False
self.of_exist = False
self.back_of_exist = False
self.depth_exist = False
elif ty == "NoOf":
self.of_exist = False
self.back_of_exist = False
elif ty == "NoDepth":
self.depth_exist = False
elif ty == "NoGT":
self.gt_exist = False
self.user["GT"] = ""
elif ty == "LabelError":
self.create_super_pixel_label = True
shutil.rmtree(
os.path.join(self.savePathJoin("Super_Pixel"),
self.super_pixel_method))
elif ty == "ObDetError":
self.object_detection_dir_exist = False
shutil.rmtree(self.savePathJoin("ObjectDetection"))
return answer == int("0x00040000", 16) or stop_calculation
def calculateError(self, errorMessage):
"""Called if there were errors while calculating the results, creates QMessageBox
Arguments:
errorMessage {str} -- error message to be shown in the QMessageBox
"""
self.no_error = False
QMessageBox.warning(self, "Found Error", errorMessage, QMessageBox.Ok,
QMessageBox.Ok)
def buildParamsDict(self):
"""Build parameter dictionary to forward parameters for the calcRunner class
"""
self.params_dict = {
"img_dir":
self.savePathJoin("Images"),
"depth_dir":
self.savePathJoin("Depth"),
"back_of_dir":
self.savePathJoin("Back_Of"),
"of_dir":
self.savePathJoin("Of"),
"save_dir":
self.user["Save"],
"high":
self.high,
"low":
self.low,
"run_dict":
self.run_dict,
"of_model":
self.app.get_resource(
os.path.join("of_models", "network-default.pytorch")),
"depth_model":
self.app.get_resource(
os.path.join("depth_models", "model_city2kitti.meta")),
"yolo_weights":
self.app.get_resource(os.path.join("yolo", "yolov3.weights")),
"yolo_v":
self.app.get_resource(os.path.join("yolo", "yolov3.cfg")),
"coco_names":
self.app.get_resource(os.path.join("yolo", "coco.names")),
"object_detection_dir":
self.savePathJoin("ObjectDetection"),
"plot_speed_dir":
PLOT_SPEED_DIR,
"plot_crash_dir":
PLOT_CRASH_DIR,
"numbers_dir":
NP_DIR,
"plot_error_dir":
PLOT_ERROR_DIR,
"speed_gt":
self.user["GT"],
"vid_path":
self.user["Video"],
"super_pixel_method":
self.super_pixel_method,
"super_pixel_dir":
SUPER_PIXEL_DIR,
"send_video_frame":
False,
"create_csv":
self.ui.c_csv.isChecked(),
"create_draw":
self.ui.c_draw.isChecked(),
"create_velocity":
self.ui.c_velocity.isChecked(),
"create_video_fps":
int(self.ui.t_fps.text()),
"optimize_params":
self.ui.c_optimize.isChecked(),
"super_pixel_label_dir":
os.path.join(self.savePathJoin("Super_Pixel"),
self.super_pixel_method),
}
def startRun(self):
"""Check for errors and start calculations
"""
self.checkFiles()
if self.errorChecks():
logging.info("Error Check Failed")
return
self.disableButtons()
self.sendUser.emit(self.user)
logging.info("Start Run Class")
self.createDirs()
self.buildRunDict()
def startCalcThread(self):
"""Starting calculations on another thread
"""
# 1 - create Worker and Thread inside the Form
self.worker = calcRunner.CalculationRunner(self.params_dict)
self.thread = QThread() # no parent!
self.worker.labelUpdate.connect(self.labelUpdate)
self.worker.update.connect(self.progressUpdate)
self.worker.error.connect(self.calculateError)
self.worker.finished.connect(self.finishThread)
self.worker.moveToThread(self.thread)
self.thread.started.connect(self.worker.startThread)
# 6 - Start the thread
self.thread.start()
def progressUpdate(self, value):
"""Updating both progressbar
Arguments:
value {int} -- current progress
"""
self.progressBar.setValue(value)
logging.info("Update progressbar to: {0}".format(self.run_count))
if self.progressAllBar is not None:
self.run_count += 1
self.progressAllBar.setValue(self.run_count)
def finishThread(self):
"""Clean up after calculations thread finished
"""
logging.info("Fin Thread")
self.buildCreatedDict()
self.cleanThread()
self.accept()
def cleanThread(self):
"""Cleans the active thread
"""
logging.info("Clean Thread")
self.thread.quit()
self.thread.wait()
def labelUpdate(self, run_dict):
"""Update progressbar label's text to show the current calculation
Arguments:
run_dict {dictionary} -- dictionary of the current process
"""
self.progressBar.reset()
self.progressBar.setMinimum(1)
self.progressBar.setMaximum(run_dict["Progress"])
self.progressLabel.setText(run_dict["Text"])
def showProgressBar(self):
"""Creates two progressbars to show how the calculation progresses
"""
logging.info("Show progress bar")
self.progressLabel = QLabel(self)
font = QFont()
font.setFamily("GE Inspira")
font.setPointSize(20)
self.progressLabel.setFont(font)
self.progressLabel.setAlignment(Qt.AlignCenter)
self.progressLabel.setText("Hello")
self.ui.layout_v.addWidget(self.progressLabel)
self.progressBar = QProgressBar(self) # Progress bar created
self.progressBar.setRange(0, 0)
self.ui.layout_v.addWidget(self.progressBar)
def addAllProgressBar(self):
"""Adds the progress bar which tracks the progress of all calculations
"""
all_run = sum([
self.run_dict[key]["Progress"] for key in self.run_dict
if self.run_dict[key]["Run"]
])
logging.info("All run: {0}".format(all_run))
self.progressAllBar = QProgressBar(self) # Progress bar created
self.progressAllBar.setMinimum(1)
self.progressAllBar.setMaximum(all_run)
self.ui.layout_v.addWidget(self.progressAllBar)
self.progressAllBar.setValue(1)
def buildCreatedDict(self):
"""Build dictionary containing the created plots (if there's any).
Send signal with this dictionary
"""
self.created = {}
if self.ui.c_speed_plot.isChecked():
self.created["Speed_Plot"] = self.savePathJoin(PLOT_SPEED_DIR)
if self.ui.c_error_plot.isChecked() and self.no_error:
self.created["Error_Plot"] = self.savePathJoin(PLOT_ERROR_DIR)
if self.ui.c_crash_plot.isChecked():
self.created["Crash_Plot"] = self.savePathJoin(PLOT_CRASH_DIR)
self.sendCreated.emit(self.created)
def buildRunDict(self):
"""Create images from video in another thread, loads the image number otherwise
"""
self.showProgressBar()
ori_images = 0
if self.img_exist:
ori_images = len(listDirectory(self.savePathJoin("Images")))
self.buildRunDictMain(ori_images)
else:
self.run_dict["Video"] = {
"Run": True,
"Progress": ori_images,
"Text": "Preparing video",
}
self.buildParamsDict()
self.params_dict["send_video_frame"] = True
self.progressLabel.setText("Create images from video")
self.worker = calcRunner.CalculationRunner(
self.params_dict) # no parent!
self.thread = QThread() # no parent!
self.worker.labelUpdate.connect(self.labelUpdate)
self.worker.update.connect(self.progressUpdate)
self.worker.videoFrame.connect(self.setVidFrame)
self.worker.moveToThread(self.thread)
self.thread.started.connect(self.worker.startThread)
self.thread.start()
def setVidFrame(self, ori_images):
"""Gets called when the image creation from video finishes
Arguments:
ori_images {int} -- number of images in the video
"""
self.cleanThread()
if ori_images == 0:
logging.critical("Video Image number 0")
else:
self.buildRunDictMain(ori_images)
def buildRunDictMain(self, ori_images):
"""Build dictionary with all calculations
Dictionary fields:
-Run: {bool} true if needs to be calculated, false otherwise
-Progress: {int} the amount of steps to complete the calculation (used to update the progressbar)
-Text: {str} the text to be showed in the progressbar label's when the calculation is running
"""
self.run_dict["Of"] = {
"Run": not self.of_exist,
"Progress": ori_images,
"Text": "Running optical flow",
}
self.run_dict["Back_Of"] = {
"Run": not self.back_of_exist,
"Progress": ori_images,
"Text": "Running back optical flow",
}
self.run_dict["Depth"] = {
"Run": not self.depth_exist,
"Progress": ori_images,
"Text": "Running depth estimation",
}
self.run_dict["Speed"] = {
"Run": True,
"Progress": ori_images,
"Text": "Running speed estimation",
}
self.run_dict["Optimization"] = {
"Run": self.ui.c_optimize.isChecked(),
"Progress": ori_images * 9,
"Text": "Running parameter optimization",
}
self.run_dict["Of_Vid"] = {
"Run": self.ui.c_of.isChecked(),
"Progress": ori_images,
"Text": "Creating optical flow video",
}
self.run_dict["Back_Of_Vid"] = {
"Run": self.ui.c_back_of.isChecked(),
"Progress": ori_images,
"Text": "Creating backward optical flow video",
}
self.run_dict["Depth_Vid"] = {
"Run": self.ui.c_depth.isChecked(),
"Progress": ori_images,
"Text": "Creating depth estimation video",
}
self.run_dict["Speed_Plot"] = {
"Run": self.ui.c_speed_plot.isChecked(),
"Progress": ori_images,
"Text": "Creating plot for speed values",
}
self.run_dict["Crash_Plot"] = {
"Run": self.ui.c_crash_plot.isChecked(),
"Progress": ori_images,
"Text": "Creating plot for time to crash",
}
self.run_dict["Error_Plot"] = {
"Run": self.ui.c_error_plot.isChecked() and self.gt_exist,
"Progress": ori_images,
"Text": "Creating plot for speed error",
}
self.run_dict["Speed_Plot_Video"] = {
"Run": self.ui.c_speed_plot_video.isChecked(),
"Progress": ori_images,
"Text": "Creating speed plot video",
}
self.run_dict["Error_Plot_Video"] = {
"Run": self.ui.c_error_plot_video.isChecked() and self.gt_exist,
"Progress": ori_images,
"Text": "Creating error plot video",
}
self.run_dict["Crash_Plot_Video"] = {
"Run": self.ui.c_crash_plot_video.isChecked(),
"Progress": ori_images,
"Text": "Creating time to crash plot video",
}
self.run_dict["Super_Pixel_Video"] = {
"Run":
self.ui.combo_superpixel.currentIndex() != 0
and self.ui.c_super_pixel_video.isChecked(),
"Progress":
ori_images,
"Text":
"Creating super pixel video",
}
self.run_dict["Super_Pixel_Label"] = {
"Run":
self.create_super_pixel_label,
"Progress":
ori_images,
"Text":
"Creating {0} superpixel labels".format(self.super_pixel_method),
}
self.run_dict["Object_Detection"] = {
"Run": (self.ui.c_object_detection.isChecked()
or self.ui.c_crash_plot.isChecked())
and not self.object_detection_dir_exist,
"Progress":
ori_images,
"Text":
"Running Object Detection",
}
self.addAllProgressBar()
self.buildParamsDict()
self.saveUser()
self.startCalcThread()
def disableButtons(self):
"""Disable widgets while the calculation is running
"""
self.ui.b_run.setEnabled(False)
self.ui.b_colour.setEnabled(False)
self.ui.b_ground_truth.setEnabled(False)
self.ui.b_vid.setEnabled(False)
self.ui.b_save.setEnabled(False)
self.ui.t_low.setEnabled(False)
self.ui.t_high.setEnabled(False)
self.ui.t_fps.setEnabled(False)
self.ui.combo_superpixel.setEnabled(False)
self.ui.c_super_pixel_video.setEnabled(False)
self.ui.c_csv.setEnabled(False)
self.ui.c_draw.setEnabled(False)
self.ui.c_velocity.setEnabled(False)
self.ui.c_of.setEnabled(False)
self.ui.c_back_of.setEnabled(False)
self.ui.c_depth.setEnabled(False)
self.ui.c_speed_plot.setEnabled(False)
self.ui.c_error_plot.setEnabled(False)
self.ui.c_crash_plot.setEnabled(False)
self.ui.c_error_plot_video.setEnabled(False)
self.ui.c_speed_plot_video.setEnabled(False)
self.ui.c_crash_plot_video.setEnabled(False)
self.ui.c_optimize.setEnabled(False)
self.ui.c_object_detection.setEnabled(False)
def savePathJoin(self, path):
"""Join the given path with the save path (stored in user info)
Arguments:
path {str} -- path to join after the save path
Returns:
str -- joined path
"""
return os.path.join(self.user["Save"], path)
def createDir(self, dir_name):
"""Create directory with the given name in the save path (stored in user info)
Arguments:
dir_name {str} -- path to the newly created dir
"""
os.mkdir(os.path.join(self.user["Save"], dir_name))
def createDirs(self):
"""Create or recreate (destroy and create) directories for the calculations
"""
logging.info("Creating Directories")
if not self.img_exist:
self.reCreateDir(self.savePathJoin("Images"))
if not self.of_exist:
self.reCreateDir(self.savePathJoin("Of"))
if not self.back_of_exist:
self.reCreateDir(self.savePathJoin("Back_Of"))
if not self.depth_exist:
self.reCreateDir(self.savePathJoin("Depth"))
if not self.object_detection_dir_exist and (
self.ui.c_object_detection.isChecked()
or self.ui.c_crash_plot.isChecked()):
self.reCreateDir(self.savePathJoin("ObjectDetection"))
if self.super_pixel_method != "" and not os.path.exists(
os.path.join(self.savePathJoin("Super_Pixel"),
self.super_pixel_method)):
os.makedirs(
os.path.join(self.savePathJoin("Super_Pixel"),
self.super_pixel_method))
self.reCreateDir(RESULTS)
self.reCreateDir(NP_DIR)
self.reCreateDir(MASK_DIR)
if self.ui.c_crash_plot.isChecked():
self.reCreateDir(PLOT_CRASH_DIR)
if self.ui.c_draw.isChecked():
self.reCreateDir(DRAW_DIR)
if self.ui.c_velocity.isChecked():
self.reCreateDir(VL_DIR)
if self.ui.c_speed_plot.isChecked():
self.reCreateDir(PLOT_SPEED_DIR)
if self.super_pixel_method != "":
self.reCreateDir(SUPER_PIXEL_DIR)
if self.user["GT"] != "" and self.ui.c_error_plot.isChecked():
self.reCreateDir(PLOT_ERROR_DIR)
def reCreateDir(self, name):
"""Create directory with the given name in save dir (stored in user info).
If it already exists, then delete it first
Arguments:
name {str} -- name of the new directory
"""
path = self.savePathJoin(name)
if os.path.exists(path):
shutil.rmtree(path)
os.makedirs(path)
def pickColour(self):
"""Opens a QColorDialog to choose a colour
"""
colour = QColorDialog.getColor()
if colour.isValid():
self.user["Colour"] = colour.name()
self.ui.l_colour.setText(self.user["Colour"])
def __init__(self, configFile):
super(WSPRUI, self).__init__()
#Things that we need to keep track of to update
self.wsprDevice = WSPRInterfaceObject(configFile)
self.bandCheckboxes = []
self.CurrentGPSStatus = QProgressBar(self)
self.gpsTime = QLabel("00:00:00")
self.gpsPosition = QLabel("0000")
self.gpsPower = QLabel("0")
self.outputFreq = QLabel(self.formatFrequency("0"))
self.setFrequencyValueLable = QLineEdit(self.formatFrequency("0"))
self.dialFrequency = QDial()
self.gpsLocked = QLabel("GPS Signal Quality:")
self.portConnectionIcon = QLabel()
self.portConnectionIcon.setFixedSize(50, 50)
self.portConnectionIcon.mousePressEvent = self.handleConnectionIconClick
self.txtCallsign = QLineEdit()
self.portConnectionLabel = QLabel(self.wsprDevice.config.notconnectedtext)
self.rdoStartUpSignalGen = QRadioButton("Signal Generator")
self.rdoStartUpWSPRBeacon = QRadioButton("WSPR Beacon")
self.rdoStartUpIdle = QRadioButton("Idle")
self.pauseAfterTransmission = QLineEdit("120")
self.manualLocationSetting = QLineEdit("FN44")
self.useManualLocation = QCheckBox()
self.chkCurrentSignalGen = QCheckBox("Signal Generator")
self.chkCurrentWSPRBeacon = QCheckBox("WSPR Beacon")
self.valCurrentMode = QLabel("")
self.transmitStatus = QLabel("")
self.buttonReload = QPushButton("Reload")
self.buttonReload.setFixedSize(100, 50)
self.buttonReload.clicked.connect(self.handleReloadPush)
self.buttonReload.setVisible(self.wsprDevice.config.debug)
self.buttonSave = QPushButton("Save")
self.buttonChangeCurrentMode = QPushButton("Start")
self.debugSection = QGroupBox("Info")
self.textArea = QPlainTextEdit()
self.textArea.setMaximumBlockCount(self.wsprDevice.config.debugAreaMaximumBlockCount)
self.textArea.setReadOnly(True)
self.commandArray = [Command.CALLSIGN,
Command.BANDS,
Command.STARTUP_MODE,
Command.CURRENT_MODE,
Command.POWER,
Command.GENERATOR_FREQUENCY]
self.factorySettingsArray = [Command.FACTORY_FREQUENCY_REFERENCE_OSCILLATOR_FREQUENCY,
Command.FACTORY_HARDWARE_REVISION,
Command.FACTORY_HARDWARE_VERSION,
Command.FACTORY_LOWPASS_FINTER_INSTALLED,
Command.FACTORY_PRODUCT_NUMBER,
Command.FACTORY_SOFTWARE_REVISION,
Command.FACTORY_SOFTWARE_VERSION]
#Create the UI
self.initUI()
#Threads
self.createThreads()
def initUI(self):
global button1
global button2
global button3
global button4
global button5
self.setWindowTitle(self.title)
self.setMaximumSize(620, 400)
self.setMinimumSize(620, 700)
self.setGeometry(self.left, self.top, self.width, self.height)
self.setWindowIcon(QIcon("images.ico"))
button1 = QPushButton('Select Files', self)
button1.setToolTip('This is an example button')
button1.move(70, 60)
button1.resize(100, 30)
button1.clicked.connect(self.openFileNamesDialog)
button2 = QPushButton('Run for All', self)
button2.setToolTip('This is an example button')
button2.move(70, 480)
button2.resize(240, 30)
button2.clicked.connect(self.trim)
button2.setEnabled(False)
button3 = QPushButton('Run for Affacted', self)
button3.setToolTip('This is an example button')
button3.move(310, 450)
button3.resize(240, 30)
button3.clicked.connect(self.trim_affacted)
button3.setEnabled(False)
button4 = QPushButton('Check Affacted Files', self)
button4.setToolTip('This is an example button')
button4.move(70, 450)
button4.resize(240, 30)
button4.clicked.connect(self.check_Extra_spaces, )
button4.setEnabled(False)
button5 = QPushButton('Reset', self)
button5.setToolTip('This is an example button')
button5.move(310, 480)
button5.resize(240, 30)
button5.clicked.connect(self.reset)
button5.setEnabled(False)
button6 = QPushButton('Close', self)
button6.setToolTip('This is an example button')
button6.move(450, 630)
button6.resize(100, 30)
button6.clicked.connect(self.close_window)
# button7 = QPushButton('See logs', self)
# button7.setToolTip('This is an example button')
# button7.move(250, 630)
# button7.resize(100, 30)
# button7.clicked.connect(self.openpop_up)
label2 = QLabel('Set Output Path :', self)
label2.move(70, 155)
global textbox1
global textbox2
global textbox3
global model, list1
textbox1 = QLineEdit(self)
textbox1.move(170, 60)
textbox1.resize(380, 30)
textbox1.setReadOnly(True)
textbox2 = QLineEdit(desktop, self)
textbox2.move(170, 150)
textbox2.resize(380, 30)
list1 = QListView(self)
list1.setWindowTitle('Affected File List')
list1.setMinimumSize(100, 200)
list1.move(70, 240)
list1.resize(480, 26)
list1.setEditTriggers(QAbstractItemView.NoEditTriggers)
global progress
progress = QProgressBar(self)
progress.move(70, 530)
progress.resize(500, 26)
progress.setValue(0)
self.show()
class ScreenshotsDialog(QDialog):
MAX_HEIGHT = 600
MAX_WIDTH = 800
def __init__(self, pkg: PackageView, http_client: HttpClient,
icon_cache: MemoryCache, i18n: I18n,
screenshots: List[QPixmap], logger: logging.Logger):
super(ScreenshotsDialog, self).__init__()
self.setWindowTitle(str(pkg))
self.screenshots = screenshots
self.logger = logger
self.loaded_imgs = []
self.download_threads = []
self.resize(1280, 720)
self.i18n = i18n
self.http_client = http_client
self.progress_bar = QProgressBar()
self.progress_bar.setMaximumHeight(10 if QApplication.instance().style(
).objectName().lower() == 'windows' else 6)
self.progress_bar.setTextVisible(False)
self.thread_progress = AnimateProgress()
self.thread_progress.signal_change.connect(self._update_progress)
self.thread_progress.start()
# THERE ARE CRASHES WITH SOME RARE ICONS ( like insomnia ). IT CAN BE A QT BUG. IN THE MEANTIME, ONLY THE TYPE ICON WILL BE RENDERED
#
# icon_data = icon_cache.get(pkg.model.icon_url)
#
# if icon_data and icon_data.get('icon'):
# self.setWindowIcon(icon_data.get('icon'))
# else:
# self.setWindowIcon(QIcon(pkg.model.get_type_icon_path()))
self.setWindowIcon(QIcon(pkg.model.get_type_icon_path()))
self.setLayout(QVBoxLayout())
self.img = QLabel()
self.layout().addWidget(self.img)
self.bottom_bar = QToolBar()
self.bt_back = QPushButton(
' < ' + self.i18n['screenshots.bt_back.label'].capitalize())
self.bt_back.setCursor(QCursor(Qt.PointingHandCursor))
self.bt_back.clicked.connect(self.back)
self.ref_bt_back = self.bottom_bar.addWidget(self.bt_back)
self.bottom_bar.addWidget(new_spacer(50))
self.img_label = QLabel()
self.img_label.setStyleSheet(
'QLabel { font-weight: bold; text-align: center }')
self.ref_img_label = self.bottom_bar.addWidget(self.img_label)
self.ref_img_label.setVisible(False)
self.ref_progress_bar = self.bottom_bar.addWidget(self.progress_bar)
self.bottom_bar.addWidget(new_spacer(50))
self.bt_next = QPushButton(
self.i18n['screenshots.bt_next.label'].capitalize() + ' > ')
self.bt_next.setCursor(QCursor(Qt.PointingHandCursor))
self.bt_next.clicked.connect(self.next)
self.ref_bt_next = self.bottom_bar.addWidget(self.bt_next)
self.layout().addWidget(self.bottom_bar)
self.img_idx = 0
for idx, s in enumerate(self.screenshots):
t = Thread(target=self._download_img, args=(idx, s), daemon=True)
t.start()
self._load_img()
def _update_progress(self, val: int):
self.progress_bar.setValue(val)
def _load_img(self):
if len(self.loaded_imgs) > self.img_idx:
img = self.loaded_imgs[self.img_idx]
if isinstance(img, QPixmap):
self.img_label.setText('')
self.img.setPixmap(img)
else:
self.img_label.setText(img)
self.img.setPixmap(QPixmap())
self.thread_progress.stop = True
self.ref_progress_bar.setVisible(False)
self.ref_img_label.setVisible(True)
else:
self.img.setPixmap(QPixmap())
self.ref_img_label.setVisible(False)
self.ref_progress_bar.setVisible(True)
self.thread_progress.start()
if len(self.screenshots) == 1:
self.ref_bt_back.setVisible(False)
self.ref_bt_next.setVisible(False)
else:
self.ref_bt_back.setEnabled(self.img_idx != 0)
self.ref_bt_next.setEnabled(
self.img_idx != len(self.screenshots) - 1)
self.adjustSize()
qt_utils.centralize(self)
def _download_img(self, idx: int, url: str):
self.logger.info('Downloading image [{}] from {}'.format(idx, url))
res = self.http_client.get(url)
if res:
if not res.content:
self.logger.warning('Image [{}] from {} has no content'.format(
idx, url))
self.loaded_imgs.append(
self.i18n['screenshots.download.no_content'])
self._load_img()
else:
self.logger.info(
'Image [{}] successfully downloaded'.format(idx))
pixmap = QPixmap()
pixmap.loadFromData(res.content)
if pixmap.size().height() > self.MAX_HEIGHT or pixmap.size(
).width() > self.MAX_WIDTH:
pixmap = pixmap.scaled(self.MAX_WIDTH, self.MAX_HEIGHT,
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.loaded_imgs.append(pixmap)
if self.img_idx == idx:
self._load_img()
else:
self.logger.info("Could not retrieve image [{}] from {}".format(
idx, url))
self.loaded_imgs.append(
self.i18n['screenshots.download.no_response'])
self._load_img()
def back(self):
self.img_idx -= 1
self._load_img()
def next(self):
self.img_idx += 1
self._load_img()
def __init__(self, pkg: PackageView, http_client: HttpClient,
icon_cache: MemoryCache, i18n: I18n,
screenshots: List[QPixmap], logger: logging.Logger):
super(ScreenshotsDialog, self).__init__()
self.setWindowTitle(str(pkg))
self.screenshots = screenshots
self.logger = logger
self.loaded_imgs = []
self.download_threads = []
self.resize(1280, 720)
self.i18n = i18n
self.http_client = http_client
self.progress_bar = QProgressBar()
self.progress_bar.setMaximumHeight(10 if QApplication.instance().style(
).objectName().lower() == 'windows' else 6)
self.progress_bar.setTextVisible(False)
self.thread_progress = AnimateProgress()
self.thread_progress.signal_change.connect(self._update_progress)
self.thread_progress.start()
# THERE ARE CRASHES WITH SOME RARE ICONS ( like insomnia ). IT CAN BE A QT BUG. IN THE MEANTIME, ONLY THE TYPE ICON WILL BE RENDERED
#
# icon_data = icon_cache.get(pkg.model.icon_url)
#
# if icon_data and icon_data.get('icon'):
# self.setWindowIcon(icon_data.get('icon'))
# else:
# self.setWindowIcon(QIcon(pkg.model.get_type_icon_path()))
self.setWindowIcon(QIcon(pkg.model.get_type_icon_path()))
self.setLayout(QVBoxLayout())
self.img = QLabel()
self.layout().addWidget(self.img)
self.bottom_bar = QToolBar()
self.bt_back = QPushButton(
' < ' + self.i18n['screenshots.bt_back.label'].capitalize())
self.bt_back.setCursor(QCursor(Qt.PointingHandCursor))
self.bt_back.clicked.connect(self.back)
self.ref_bt_back = self.bottom_bar.addWidget(self.bt_back)
self.bottom_bar.addWidget(new_spacer(50))
self.img_label = QLabel()
self.img_label.setStyleSheet(
'QLabel { font-weight: bold; text-align: center }')
self.ref_img_label = self.bottom_bar.addWidget(self.img_label)
self.ref_img_label.setVisible(False)
self.ref_progress_bar = self.bottom_bar.addWidget(self.progress_bar)
self.bottom_bar.addWidget(new_spacer(50))
self.bt_next = QPushButton(
self.i18n['screenshots.bt_next.label'].capitalize() + ' > ')
self.bt_next.setCursor(QCursor(Qt.PointingHandCursor))
self.bt_next.clicked.connect(self.next)
self.ref_bt_next = self.bottom_bar.addWidget(self.bt_next)
self.layout().addWidget(self.bottom_bar)
self.img_idx = 0
for idx, s in enumerate(self.screenshots):
t = Thread(target=self._download_img, args=(idx, s), daemon=True)
t.start()
self._load_img()
class Window(QMainWindow, Ui_MainWindow):
state_change = pyqtSignal()
def __init__(self):
super(Window, self).__init__()
self.final_clip = None
self.audio_backend = None
self.video_backend = None
self.audio = None
self.cutter_end = 0
self.cutter_start = 0
self.product = ''
self.index = 0
self.generator = None
self.t = 0
self.tt = None
self.setupUi(self)
self.pushButton.clicked.connect(self.openFile)
# self.pushButton_3.clicked.connect(self.process)
self.pushButton_3.setEnabled(False)
self.pushButton_2.setEnabled(False)
self.pushButton_2.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
self.pushButton_2.clicked.connect(self.play)
self.pushButton_9.clicked.connect(self.tiktok)
self.horizontalSlider.setRange(0, 0)
# self.horizontalSlider.sliderMoved.connect(self.setPosition)
self.progressBar = QProgressBar()
self.progressBar.setVisible(False)
self.progressBar.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.statusbar.addPermanentWidget(self.progressBar)
self.widget = MyWidget()
self.state_change.connect(self.fitState)
self.widget.finish.connect(self.processfinish)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.widget.sizePolicy().hasHeightForWidth())
self.widget.setSizePolicy(sizePolicy)
self.gridLayout.addWidget(self.widget, 0, 0, 1, 1)
self.timer = QTimer()
self.timer.setTimerType(Qt.PreciseTimer)
self.timer.timeout.connect(self.widget.update)
self.state = State.IDLE
self.playObject = None
self.playThread = None
def tiktok(self):
temp = time.time()
self.video_backend = self.video_backend.fl_image(tiktok_effect)
print("copy time: %f" % (time.time() - temp))
def fitState(self):
if self.state == State.PLAYING:
self.pushButton_2.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
elif self.state in (State.PAUSE, State.IDLE, State.FINISHED):
self.pushButton_2.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def processfinish(self):
self.state = State.FINISHED
self.t = 0
self.state_change.emit()
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(
self, "Open Video", QDir.homePath(),
"Video(*.mp4;*.wmv;*.rmvb;*.avi)")
if fileName != '':
if self.video_backend is not None:
self.video_backend.close()
if self.audio_backend is not None:
self.audio_backend.close()
self.video_backend = VideoFileClip(fileName)
# self.video_backend = clip.resize(width=clip.w//2,height=clip.h//2)
self.audio_backend = self.video_backend.audio
fps = self.video_backend.fps
duration = self.video_backend.duration
self.tt = np.arange(0, duration, 1.0 / fps)
self.widget.drawFrame(0)
if self.state != State.IDLE:
self.audio.stop()
self.timer.stop()
self.t = 0
self.state = State.IDLE
self.state_change.emit()
else:
self.pushButton_2.setEnabled(True)
self.pushButton_3.setEnabled(True)
def play(self):
if self.state in (State.IDLE, State.FINISHED):
self.state = State.PLAYING
self.state_change.emit()
self.timer.start(1000 / self.video_backend.fps)
if self.audio_backend is not None:
blocksize = int(1.0 / self.video_backend.fps *
self.audio_backend.fps)
self.audio = audio(self.audio_backend, self.audio_backend.fps,
blocksize, 2)
self.audio.start()
elif self.state == State.PLAYING:
self.state = State.PAUSE
self.timer.stop()
self.audio.pause()
self.state_change.emit()
elif self.state == State.PAUSE:
self.audio.resume()
self.timer.start(1000 / self.video_backend.fps)
self.state = State.PLAYING
self.state_change.emit()
class window(QMainWindow):
def __init__(self):
super(window, self).__init__()
self.setGeometry(50, 50, 500, 300)
self.setWindowTitle(' lesson 5 liao !')
self.setWindowIcon(QIcon('icon-mongol.jpg'))
extractAction = QAction(' Get to the choppa', self)
extractAction.setShortcut('Ctrl+Q')
extractAction.setStatusTip('leave the app')
extractAction.triggered.connect(self.close_application)
openEditor = QAction("&Editor", self)
openEditor.setShortcut("Ctrl+E")
openEditor.setStatusTip('Open Editor')
openEditor.triggered.connect(self.editor)
openFile = QAction("&Open File", self)
openFile.setShortcut("Ctrl+O")
openFile.setStatusTip('Open File')
openFile.triggered.connect(self.file_open)
self.statusBar()
mainMenu = self.menuBar()
fileMenu = mainMenu.addMenu('&File')
fileMenu.addAction(extractAction)
editorMenu = mainMenu.addMenu("&Editor")
editorMenu.addAction(openEditor)
fileMenu.addAction(openFile)
self.home()
def home(self):
btn = QPushButton('quit', self)
btn.clicked.connect(self.close_application)
# btn.resize(btn.sizeHint()) # auto size for btn
btn.resize(btn.minimumSizeHint())
btn.move(0, 100)
extractAction = QAction(QIcon('icon-smoker.jpg'), 'Flee the scene',
self)
extractAction.triggered.connect(self.close_application)
self.toolBar = self.addToolBar('Extraction')
self.toolBar.addAction(extractAction)
bsAction = QAction(QIcon('icon-me.jpg'), 'bullshit time', self)
bsAction.triggered.connect(self.bullshit)
self.toolBar.addAction(bsAction)
fontChoice = QAction('font', self)
fontChoice.triggered.connect(self.font_choice)
self.toolBar.addAction(fontChoice)
color = QColor(0, 0, 0)
fontColor = QAction('Font bg Color', self)
fontColor.triggered.connect(self.color_picker)
self.toolBar.addAction(fontColor)
cal = QCalendarWidget(self)
cal.move(500, 200)
cal.resize(200, 200)
checkBox = QCheckBox('window size', self)
checkBox.move(300, 25)
# checkBox.toggle()
checkBox.stateChanged.connect(self.enlargeWindow)
self.progress = QProgressBar(self)
self.progress.setGeometry(200, 80, 250, 20)
self.btn = QPushButton('download', self)
self.btn.move(200, 120)
self.btn.clicked.connect(self.download)
# print(self.style().objectName())
self.styleChoice = QLabel('Windows', self)
comboBox = QComboBox(self)
# comboBox.addItem('motif')
# comboBox.addItem('Windows')
# comboBox.addItem('cde')
# comboBox.addItem('Plastique')
# comboBox.addItem('Cleanlooks')
# comboBox.addItem('windowsvista')
comboBox.addItems(QStyleFactory.keys())
comboBox.move(25, 250)
self.styleChoice.move(50, 150)
comboBox.activated[str].connect(self.style_choice)
self.show()
def color_picker(self):
color = QColorDialog.getColor()
self.styleChoice.setStyleSheet("QWidget {background-color: %s}" %
color.name())
def file_open(self):
'''need to make name an tupple otherwise i had an error and app crashed'''
name, _ = QFileDialog.getOpenFileName(
self, 'Open File', options=QFileDialog.DontUseNativeDialog)
print('name', name, '2nd thing', _)
file = open(name, 'r')
self.editor()
with file:
text = file.read()
self.textEdit.setText(text)
def editor(self):
self.textEdit = QTextEdit()
self.setCentralWidget(self.textEdit) # take up all the space
def font_choice(self):
font, valid = QFontDialog.getFont()
if valid:
self.styleChoice.setFont(font)
def style_choice(self, text):
self.styleChoice.setText(text)
self.styleChoice.resize(
self.styleChoice.sizeHint()) # change font size on render
QApplication.setStyle(QStyleFactory.create(text))
def download(self):
self.completed = 0
while self.completed < 100:
self.completed += 0.0001
self.progress.setValue(self.completed)
def close_application(self):
# print('whoooo sooo custooom')
choice = QMessageBox.question(self, 'Extract', "Get into the choppa?",
QMessageBox.Yes | QMessageBox.No)
if choice == QMessageBox.Yes:
print('Extracting Naaaoooowww!')
sys.exit()
else:
pass
# def closeEvent(self, event): # actually works in pyqt5 too
# event.ignore()
# self.close_application()
def closeEvent(self, QCloseEvent):
'''for closing the window from the corner "x" '''
QCloseEvent.ignore()
self.close_application()
def bullshit(self):
print('I am the greatest!!!')
def enlargeWindow(self, state):
if state == Qt.Checked:
self.setGeometry(50, 50, 1000, 600)
else:
self.setGeometry(50, 50, 500, 300)
def setupStatusBar(self, iface, previewEnabled=True):
w = QProgressBar(self.ui.statusbar)
w.setObjectName("progressBar")
w.setMaximumWidth(250)
w.setAlignment(Qt.AlignCenter)
w.setVisible(False)
self.ui.statusbar.addPermanentWidget(w)
self.ui.progressBar = w
w = QCheckBox(self.ui.statusbar)
w.setObjectName("checkBoxPreview")
w.setText("Preview") # _translate("Q3DWindow", "Preview"))
w.setChecked(previewEnabled)
self.ui.statusbar.addPermanentWidget(w)
self.ui.checkBoxPreview = w
self.ui.checkBoxPreview.toggled.connect(iface.previewStateChanged)
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.vocalMax = 60
self.vocalMin = 50
self.move(100, 100)
self.songfile = '../data/13_LeadVox.wav'
self.m = PlotCanvas(self,
width=5,
height=4,
songfile=self.songfile,
vocalRange=[self.vocalMin, self.vocalMax])
self.m.move(0, 70)
self.addToolBar(NavigationToolbar(self.m, self))
button = QPushButton('Change Plot', self)
button.setToolTip('This s an example button')
button.clicked.connect(self.m.plot)
button.move(500, 20)
button.resize(140, 20)
button = QPushButton('Input', self)
button.setToolTip('This s an example button')
button.clicked.connect(self.getInteger)
button.move(500, 40)
button.resize(140, 20)
button = QPushButton('Open File', self)
button.setToolTip('This s an example button')
button.clicked.connect(self.getSongName)
button.move(500, 60)
button.resize(140, 20)
self.label = QLabel(self)
self.label.move(500, 80)
self.label.resize(140, 40)
self.label.show()
self.songNameLabel = QLabel(self)
newfont = QFont("Times", 12, QFont.Normal)
self.songNameLabel.setFont(newfont)
self.songNameLabel.move(10, 35)
self.songNameLabel.resize(500, 40)
self.songNameLabel.setWordWrap(True)
self.songNameLabel.setAlignment(Qt.AlignTop)
self.songNameLabel.show()
self.songScoreLabel = QLabel(self)
newfont = QFont("Times", 16, QFont.Bold)
self.songScoreLabel.setFont(newfont)
self.songScoreLabel.move(500, 130)
self.songScoreLabel.resize(140, 30)
self.songScoreLabel.show()
self.progressBar = QProgressBar(self)
self.progressBar.setRange(0, 1)
self.progressBar.move(self.width - 140, self.height - 20)
self.progressBar.resize(140, 20)
self.progressBar.show()
self.show()
self.updateLabel()
class MainWindow(QWidget):
progress_signal = pyqtSignal(object)
complete_signal = pyqtSignal(object)
error_signal = pyqtSignal(object)
def __init__(self):
super().__init__()
self.dev = None
self.progress_signal.connect(self._on_progress)
self.complete_signal.connect(self._on_complete)
self.error_signal.connect(self._on_error)
lbl_warning = QLabel(
"<font color='red'><b>Make sure jumploader is installed before you flash QMK</b></font>"
)
lbl_warning.setWordWrap(True)
btn_flash_qmk = QPushButton("Flash QMK...")
btn_flash_qmk.clicked.connect(self.on_click_flash_qmk)
lbl_help = QLabel(
"After jumploader is installed, hold Backspace while plugging in the keyboard to start in bootloader mode."
)
lbl_help.setWordWrap(True)
btn_reboot_bl = QPushButton("Reboot to Bootloader")
btn_reboot_bl.clicked.connect(self.on_click_reboot)
btn_flash_jumploader = QPushButton("Flash Jumploader")
btn_flash_jumploader.clicked.connect(self.on_click_flash_jumploader)
btn_restore_stock = QPushButton("Revert to Stock Firmware")
btn_restore_stock.clicked.connect(self.on_click_revert)
self.progress = QProgressBar()
self.progress.setRange(0, 100)
self.progress_label = QLabel("Ready")
self.combobox_devices = QComboBox()
btn_refresh_devices = QToolButton()
btn_refresh_devices.setToolButtonStyle(Qt.ToolButtonTextOnly)
btn_refresh_devices.setText("Refresh")
btn_refresh_devices.clicked.connect(self.on_click_refresh)
devices_layout = QHBoxLayout()
devices_layout.addWidget(self.combobox_devices)
devices_layout.addWidget(btn_refresh_devices)
layout_qmk = QVBoxLayout()
layout_qmk.setAlignment(Qt.AlignTop)
layout_qmk.addWidget(lbl_warning)
layout_qmk.addWidget(btn_flash_qmk)
layout_qmk.addWidget(lbl_help)
layout_stock = QVBoxLayout()
layout_stock.setAlignment(Qt.AlignTop)
layout_stock.addWidget(btn_reboot_bl)
layout_stock.addWidget(btn_flash_jumploader)
layout_stock.addWidget(btn_restore_stock)
layout_progress = QVBoxLayout()
layout_progress.addWidget(self.progress_label)
layout_progress.addWidget(self.progress)
group_qmk = QGroupBox("QMK")
group_qmk.setLayout(layout_qmk)
group_stock = QGroupBox("Stock")
group_stock.setLayout(layout_stock)
group_progress = QGroupBox("")
group_progress.setLayout(layout_progress)
group_layout = QHBoxLayout()
group_layout.addWidget(group_qmk)
group_layout.addWidget(group_stock)
layout = QVBoxLayout()
layout.addLayout(devices_layout, stretch=0)
layout.addLayout(group_layout, stretch=1)
layout.addWidget(group_progress, stretch=0)
self.setLayout(layout)
self.lockable = [
btn_flash_qmk, btn_reboot_bl, btn_flash_jumploader,
btn_restore_stock, self.combobox_devices, btn_refresh_devices
]
self.on_click_refresh()
def lock_user(self):
for obj in self.lockable:
obj.setEnabled(False)
def unlock_user(self):
self.close_dev()
for obj in self.lockable:
obj.setEnabled(True)
def close_dev(self):
if self.dev is not None:
self.dev.close()
self.dev = None
def _on_progress(self, args):
msg, progress = args
progress = int(progress * 100)
self.progress.setValue(progress)
self.progress_label.setText(msg)
def _on_complete(self, args):
self.progress.setValue(100)
self.progress_label.setText("Finished")
self.on_click_refresh()
self.unlock_user()
def _on_error(self, msg):
self.progress_label.setText("Failed")
QMessageBox.critical(window, "Error", msg)
self.unlock_user()
def on_progress(self, msg, progress):
self.progress_signal.emit([msg, progress])
def on_complete(self):
self.complete_signal.emit(None)
def on_error(self, msg):
self.error_signal.emit(msg)
def on_click_refresh(self):
self.devices = []
self.combobox_devices.clear()
for dev in hid.enumerate():
vid, pid = dev["vendor_id"], dev["product_id"]
if (vid, pid) in DEVICE_DESC:
self.combobox_devices.addItem(
"{} [{:04X}:{:04X}:{:02X}:{:02X}]".format(
DEVICE_DESC[(vid, pid)], vid, pid,
dev["interface_number"], dev["usage"]))
self.devices.append(dev)
def get_active_device(self):
idx = self.combobox_devices.currentIndex()
if idx == -1:
self._on_error("No device selected")
return None
try:
dev = hid.device()
dev.open_path(self.devices[idx]["path"])
return dev
except OSError:
self._on_error(
"Failed to open the device. You might not have sufficient permissions."
)
return None
def sanity_check_qmk_firmware(self, firmware):
# check the size so we don't trash bootloader
# (ok, we wouldn't overwrite it anyway as it's checked again in cmd_flash)
if len(firmware) > QMK_MAX_FIRMWARE:
self._on_error(
"Firmware is too large: 0x{:X} max allowed is 0x{:X}".format(
len(firmware), QMK_MAX_FIRMWARE))
return False
if len(firmware) < 0x100:
self._on_error("Firmware is too small")
return False
firmware_valid = True
# check stack pointer is valid and that first 3 vectors have bit0 set
sp, *vecs = struct.unpack("<IIII", firmware[0:16])
if sp < 0x20000000 or sp > 0x20000800 or vecs[0] & 1 != 1 or vecs[
1] & 1 != 1 or vecs[2] & 1 != 1:
self._on_error("Firmware appears to be corrupted")
return False
return True
def on_click_flash_qmk(self):
self.dev = self.get_active_device()
if not self.dev:
return
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
filename = QFileDialog.getOpenFileName(None,
"Select firmware to flash",
"",
"Firmware Files (*.bin)",
options=options)[0]
if not filename:
self.close_dev()
return
with open(filename, "rb") as inf:
firmware = inf.read()
if not self.sanity_check_qmk_firmware(firmware):
self.close_dev()
return
self.lock_user()
threading.Thread(target=lambda: cmd_flash(
self.dev, QMK_OFFSET, firmware, self.on_progress, self.on_complete,
self.on_error)).start()
def on_click_reboot(self):
self.dev = self.get_active_device()
if not self.dev:
return
self.lock_user()
threading.Thread(
target=lambda: cmd_reboot(self.dev, self.on_progress, self.
on_complete, self.on_error)).start()
def dangerous_flash(self, path):
reply = QMessageBox.question(
self, "Warning",
"This is a potentially dangerous operation, are you sure you want to continue?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply != QMessageBox.Yes:
return
self.dev = self.get_active_device()
if not self.dev:
return
with open(path, "rb") as inf:
firmware = inf.read()
self.lock_user()
threading.Thread(
target=lambda: cmd_flash(self.dev, 0, firmware, self.on_progress,
self.on_complete, self.on_error)).start()
def on_click_revert(self):
self.dangerous_flash(appctxt.get_resource("stock-firmware.bin"))
def on_click_flash_jumploader(self):
self.dangerous_flash(appctxt.get_resource("jumploader.bin"))
class App(QMainWindow):
def __init__(self):
super().__init__()
self.left = 10
self.top = 10
self.title = 'MIR Final Demo'
self.width = 640
self.height = 450
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.vocalMax = 60
self.vocalMin = 50
self.move(100, 100)
self.songfile = '../data/13_LeadVox.wav'
self.m = PlotCanvas(self,
width=5,
height=4,
songfile=self.songfile,
vocalRange=[self.vocalMin, self.vocalMax])
self.m.move(0, 70)
self.addToolBar(NavigationToolbar(self.m, self))
button = QPushButton('Change Plot', self)
button.setToolTip('This s an example button')
button.clicked.connect(self.m.plot)
button.move(500, 20)
button.resize(140, 20)
button = QPushButton('Input', self)
button.setToolTip('This s an example button')
button.clicked.connect(self.getInteger)
button.move(500, 40)
button.resize(140, 20)
button = QPushButton('Open File', self)
button.setToolTip('This s an example button')
button.clicked.connect(self.getSongName)
button.move(500, 60)
button.resize(140, 20)
self.label = QLabel(self)
self.label.move(500, 80)
self.label.resize(140, 40)
self.label.show()
self.songNameLabel = QLabel(self)
newfont = QFont("Times", 12, QFont.Normal)
self.songNameLabel.setFont(newfont)
self.songNameLabel.move(10, 35)
self.songNameLabel.resize(500, 40)
self.songNameLabel.setWordWrap(True)
self.songNameLabel.setAlignment(Qt.AlignTop)
self.songNameLabel.show()
self.songScoreLabel = QLabel(self)
newfont = QFont("Times", 16, QFont.Bold)
self.songScoreLabel.setFont(newfont)
self.songScoreLabel.move(500, 130)
self.songScoreLabel.resize(140, 30)
self.songScoreLabel.show()
self.progressBar = QProgressBar(self)
self.progressBar.setRange(0, 1)
self.progressBar.move(self.width - 140, self.height - 20)
self.progressBar.resize(140, 20)
self.progressBar.show()
self.show()
self.updateLabel()
def getVocalValue(self):
return self.vocalMin, self.vocalMax
def getInteger(self):
dialog = Dialog(parent=self)
if dialog.exec_():
#todo
self.vocalMax, self.vocalMin = dialog.value()
self.updateLabel()
self.m.computeSongFeatureScore(self.vocalMin, self.vocalMax)
self.m.plot()
dialog.destroy()
def getSongName(self):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(
self,
"QFileDialog.getOpenFileName()",
"",
"All Files (*);;Wave Files (*.wave)",
options=options)
oldSongFile = self.songfile
if fileName:
self.songfile = fileName
print('load new song:', fileName)
self.updateLoadingLabel()
ok = self.m.loadSong(self.songfile)
#task = loadSongTaskThread()
if ok:
self.m.computeSongFeatureScore(self.vocalMin, self.vocalMax)
self.updateLabel()
self.m.plot()
else:
self.songfile = oldSongFile
self.updateLabel()
else:
QMessageBox.critical(self, 'File name error', u'沒有此檔案或檔名錯誤!',
QMessageBox.Ok, QMessageBox.Ok)
self.songfile = oldSongfile
return False
def updateLabel(self):
self.label.setText("Vocal Range: \nmin:{min}, max:{max}".format(
min=self.vocalMin, max=self.vocalMax))
self.songNameLabel.setText("Song: \n{}".format(self.songfile))
self.songScoreLabel.setText(
"Score: {s:2.2f}".format(s=self.m.data[-1]))
def updateLoadingLabel(self):
print('update loading label')
self.songNameLabel.setText("Loading Song: \n{}".format(self.songfile))
def updateProgressBar(self, text, value):
self.progress_bar.setValue(value)
class WidgetGallery(QDialog):
def __init__(self, parent=None):
super(WidgetGallery, self).__init__(parent)
self.originalPalette = QApplication.palette()
styleComboBox = QComboBox()
styleComboBox.addItems(QStyleFactory.keys())
styleLabel = QLabel("&Style:")
styleLabel.setBuddy(styleComboBox)
self.useStylePaletteCheckBox = QCheckBox("&Use style's standard palette")
self.useStylePaletteCheckBox.setChecked(True)
disableWidgetsCheckBox = QCheckBox("&Disable widgets")
self.createTopLeftGroupBox()
self.createTopRightGroupBox()
self.createBottomLeftTabWidget()
self.createBottomRightGroupBox()
self.createProgressBar()
styleComboBox.activated[str].connect(self.changeStyle)
self.useStylePaletteCheckBox.toggled.connect(self.changePalette)
disableWidgetsCheckBox.toggled.connect(self.topLeftGroupBox.setDisabled)
disableWidgetsCheckBox.toggled.connect(self.topRightGroupBox.setDisabled)
disableWidgetsCheckBox.toggled.connect(self.bottomLeftTabWidget.setDisabled)
disableWidgetsCheckBox.toggled.connect(self.bottomRightGroupBox.setDisabled)
topLayout = QHBoxLayout()
topLayout.addWidget(styleLabel)
topLayout.addWidget(styleComboBox)
topLayout.addStretch(1)
topLayout.addWidget(self.useStylePaletteCheckBox)
topLayout.addWidget(disableWidgetsCheckBox)
mainLayout = QGridLayout()
mainLayout.addLayout(topLayout, 0, 0, 1, 2)
mainLayout.addWidget(self.topLeftGroupBox, 1, 0)
mainLayout.addWidget(self.topRightGroupBox, 1, 1)
mainLayout.addWidget(self.bottomLeftTabWidget, 2, 0)
mainLayout.addWidget(self.bottomRightGroupBox, 2, 1)
mainLayout.addWidget(self.progressBar, 3, 0, 1, 2)
mainLayout.setRowStretch(1, 1)
mainLayout.setRowStretch(2, 1)
mainLayout.setColumnStretch(0, 1)
mainLayout.setColumnStretch(1, 1)
self.setLayout(mainLayout)
self.setWindowTitle("Styles")
self.changeStyle('Windows')
def changeStyle(self, styleName):
QApplication.setStyle(QStyleFactory.create(styleName))
self.changePalette()
def changePalette(self):
if self.useStylePaletteCheckBox.isChecked():
QApplication.setPalette(QApplication.style().standardPalette())
else:
QApplication.setPalette(self.originalPalette)
def advanceProgressBar(self):
curVal = self.progressBar.value()
maxVal = self.progressBar.maximum()
self.progressBar.setValue(curVal + (maxVal - curVal) / 100)
def createTopLeftGroupBox(self):
self.topLeftGroupBox = QGroupBox("Group 1")
radioButton1 = QRadioButton("Radio button 1")
radioButton2 = QRadioButton("Radio button 2")
radioButton3 = QRadioButton("Radio button 3")
radioButton1.setChecked(True)
checkBox = QCheckBox("Tri-state check box")
checkBox.setTristate(True)
checkBox.setCheckState(Qt.PartiallyChecked)
layout = QVBoxLayout()
layout.addWidget(radioButton1)
layout.addWidget(radioButton2)
layout.addWidget(radioButton3)
layout.addWidget(checkBox)
layout.addStretch(1)
self.topLeftGroupBox.setLayout(layout)
def createTopRightGroupBox(self):
self.topRightGroupBox = QGroupBox("Group 2")
defaultPushButton = QPushButton("Default Push Button")
defaultPushButton.setDefault(True)
togglePushButton = QPushButton("Toggle Push Button")
togglePushButton.setCheckable(True)
togglePushButton.setChecked(True)
flatPushButton = QPushButton("Flat Push Button")
flatPushButton.setFlat(True)
layout = QVBoxLayout()
layout.addWidget(defaultPushButton)
layout.addWidget(togglePushButton)
layout.addWidget(flatPushButton)
layout.addStretch(1)
self.topRightGroupBox.setLayout(layout)
def createBottomLeftTabWidget(self):
self.bottomLeftTabWidget = QTabWidget()
self.bottomLeftTabWidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Ignored)
tab1 = QWidget()
tableWidget = QTableWidget(10, 10)
tab1hbox = QHBoxLayout()
tab1hbox.setContentsMargins(5, 5, 5, 5)
tab1hbox.addWidget(tableWidget)
tab1.setLayout(tab1hbox)
tab2 = QWidget()
textEdit = QTextEdit()
textEdit.setPlainText("Twinkle, twinkle, little star,\n"
"How I wonder what you are.\n"
"Up above the world so high,\n"
"Like a diamond in the sky.\n"
"Twinkle, twinkle, little star,\n"
"How I wonder what you are!\n")
tab2hbox = QHBoxLayout()
tab2hbox.setContentsMargins(5, 5, 5, 5)
tab2hbox.addWidget(textEdit)
tab2.setLayout(tab2hbox)
self.bottomLeftTabWidget.addTab(tab1, "&Table")
self.bottomLeftTabWidget.addTab(tab2, "Text &Edit")
def createBottomRightGroupBox(self):
self.bottomRightGroupBox = QGroupBox("Group 3")
self.bottomRightGroupBox.setCheckable(True)
self.bottomRightGroupBox.setChecked(True)
lineEdit = QLineEdit('s3cRe7')
lineEdit.setEchoMode(QLineEdit.Password)
spinBox = QSpinBox(self.bottomRightGroupBox)
spinBox.setValue(50)
dateTimeEdit = QDateTimeEdit(self.bottomRightGroupBox)
dateTimeEdit.setDateTime(QDateTime.currentDateTime())
slider = QSlider(Qt.Horizontal, self.bottomRightGroupBox)
slider.setValue(40)
scrollBar = QScrollBar(Qt.Horizontal, self.bottomRightGroupBox)
scrollBar.setValue(60)
dial = QDial(self.bottomRightGroupBox)
dial.setValue(30)
dial.setNotchesVisible(True)
layout = QGridLayout()
layout.addWidget(lineEdit, 0, 0, 1, 2)
layout.addWidget(spinBox, 1, 0, 1, 2)
layout.addWidget(dateTimeEdit, 2, 0, 1, 2)
layout.addWidget(slider, 3, 0)
layout.addWidget(scrollBar, 4, 0)
layout.addWidget(dial, 3, 1, 2, 1)
layout.setRowStretch(5, 1)
self.bottomRightGroupBox.setLayout(layout)
def createProgressBar(self):
self.progressBar = QProgressBar()
self.progressBar.setRange(0, 10000)
self.progressBar.setValue(0)
timer = QTimer(self)
timer.timeout.connect(self.advanceProgressBar)
timer.start(1000)
class VideoWidget(QWidget): #QDock
Widgets = []
# Passthrough click events
mouse_down = pyqtSignal(tuple)
mouse_move = pyqtSignal(tuple)
mouse_up = pyqtSignal(tuple)
mouse_over = pyqtSignal(Video)
mouse_leave = pyqtSignal(Video)
scroll_event = pyqtSignal(Video, int, float, float)
def __init__(self, name="Video", path=None, toolbar=None):
super().__init__()
# self.setFloating(False)
# self.setFeatures(QDockWidget.DockWidgetMovable)
# self.setAllowedAreas(Qt.AllDockWidgetAreas)
# Structure
self.setLayout(QVBoxLayout())
self.setObjectName("VideoWidget")
# Close button
self.closeButton = QPushButton()
self.closeButton.setText("X")
self.closeButton.setEnabled(True)
self.closeButton.clicked.connect(self.deleteLater)
self.layout().addWidget(self.closeButton)
# Video
self.videoContainer = QWidget()
self.videoContainer.setLayout(QStackedLayout())
self.video = Video(None, video=path)
self.videoContainer.layout().addWidget(self.video)
self.layout().addWidget(self.videoContainer)
self.video.stateChanged.connect(self.__onPlayerStateChange)
# self.video.setFixedWidth(640)
# Buttons
self.buttonRow = QWidget()
self.buttonRowLayout = QHBoxLayout()
self.buttonRow.setLayout(self.buttonRowLayout)
self.layout().addWidget(self.buttonRow)
# Play
self.playButton = QPushButton()
self.playButton.setText("Play")
self.playButton.setEnabled(False)
self.playButton.clicked.connect(self.play)
self.buttonRowLayout.addWidget(self.playButton)
# Progress Bar
self.progressSlider = QSlider(Qt.Horizontal)
self.progressSlider.setRange(0, int(self.video.number_of_frames - 1))
self.progressSlider.sliderMoved.connect(
self.setPosition) # set position when user moves slider
self.progressSlider.sliderPressed.connect(
self.video.pause) # pause when user presses slider
self.video.positionChanged.connect(
self.progressSlider.setValue) # update the slider as video plays
self.buttonRowLayout.addWidget(self.progressSlider)
# Passthrough click events
self.video.mouse_down.connect(self.mouse_down.emit)
self.video.mouse_move.connect(self.mouse_move.emit)
self.video.mouse_up.connect(self.mouse_up.emit)
self.video.mouse_over.connect(
lambda data: self.mouse_over.emit(data[1]))
self.video.mouse_leave.connect(
lambda data: self.mouse_leave.emit(data[1]))
self.video.scroll_event.connect(
lambda val, x, y: self.scroll_event.emit(self.video, val, x, y))
# Register with Toolbar
toolbar.register_video(self)
VideoWidget.Widgets.append(self)
self.destroyed.connect(lambda: VideoWidget.Widgets.remove(self)
) # TODO: check if this works
@property
def display_resolution(self):
return (self.video.size().width(), self.video.size().height())
@property
def video_resolution(self):
return self.video.resolution
def pause(self):
self.video.pause()
def play(self):
''' plays or pauses video '''
if self.video.playing:
self.video.pause()
else:
self.video.play()
def __onPlayerStateChange(self, state):
''' changes the play/pause button depending on state '''
if state:
self.playButton.setText("Pause")
else:
self.playButton.setText("Play")
def setPosition(self, pos):
''' Sets the current playback position of the video '''
self.video.setPosition(pos)
def reblit(self):
self.video.reblit()
def export(self, filename):
# QThread.thread()
# threading.Thread(target=self.video.export, args=(filename, ))
self.__export_progress_bar = QProgressBar()
self.layout().addWidget(self.__export_progress_bar)
self.__export_progress_bar.setGeometry(200, 80, 250, 20)
self.video.export(filename, self.__export_progress_bar)
# def __onVideoDurationChange(self, duration):
# self.progressSlider.setRange(0, duration)
def deleteLater(self) -> None:
print("Deleting")
self.video.deleteLater()
print("Deleted Video")
return super().deleteLater()
class TabGovernance_gui(QWidget):
def __init__(self, caller, *args, **kwargs):
QWidget.__init__(self)
self.caller = caller
self.initLayout()
self.loadIcons()
self.refreshProposals_btn.setIcon(self.refresh_icon)
self.budgetProjection_btn.setIcon(self.list_icon)
self.timeIconLabel.setPixmap(
self.time_icon.scaledToHeight(20, Qt.SmoothTransformation))
self.questionLabel.setPixmap(
self.question_icon.scaledToHeight(15, Qt.SmoothTransformation))
self.loadCacheData()
def initLayout(self):
layout = QVBoxLayout(self)
## -- ROW 1
row = QHBoxLayout()
self.budgetProjection_btn = QPushButton()
self.budgetProjection_btn.setToolTip("Check Budget Projection...")
row.addWidget(self.budgetProjection_btn)
self.selectMN_btn = QPushButton("Select Masternodes...")
row.addWidget(self.selectMN_btn)
self.selectedMNlabel = QLabel(
"<em>0 masternodes selected for voting</em")
row.addWidget(self.selectedMNlabel)
row.addStretch(1)
self.statusLabel = QLabel("")
self.statusLabel.setMinimumWidth(116)
self.resetStatusLabel('<b style="color:red">Reload Proposals</b>')
row.addWidget(self.statusLabel)
row.addStretch(1)
self.mnCountLabel = QLabel()
row.addWidget(self.mnCountLabel)
self.refreshProposals_btn = QPushButton()
self.refreshProposals_btn.setToolTip("Refresh Proposal List")
row.addWidget(self.refreshProposals_btn)
self.toggleExpiring_btn = QPushButton("Hide Expiring")
self.toggleExpiring_btn.setToolTip(
"Hide expiring proposals (yellow background) from list")
row.addWidget(self.toggleExpiring_btn)
layout.addLayout(row)
## -- ROW 2
self.proposalBox = QTableWidget()
self.proposalBox.setMinimumHeight(280)
self.proposalBox.setSelectionMode(QAbstractItemView.MultiSelection)
self.proposalBox.setSelectionBehavior(QAbstractItemView.SelectRows)
self.proposalBox.setShowGrid(True)
self.proposalBox.setColumnCount(8)
self.proposalBox.setRowCount(0)
self.proposalBox.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.proposalBox.setSortingEnabled(True)
#self.proposalBox.verticalHeader().hide
self.setProposalBoxHeader()
self.proposalBox.setColumnWidth(1, 50)
self.proposalBox.setColumnWidth(2, 50)
self.proposalBox.setColumnWidth(3, 100)
self.proposalBox.setColumnWidth(4, 100)
self.proposalBox.setColumnWidth(5, 150)
self.proposalBox.setColumnWidth(6, 120)
self.proposalBox.setColumnWidth(7, 50)
layout.addWidget(self.proposalBox)
## -- ROW 3
row = QHBoxLayout()
self.timeIconLabel = QLabel()
self.timeIconLabel.setToolTip(
"Check to add a randomized time offset (positive or negative) to enhance privacy"
)
row.addWidget(self.timeIconLabel)
self.randomDelayCheck = QCheckBox()
self.randomDelayCheck.setToolTip(
"Check to add a randomized time offset when voting (max +5/-5 hrs)"
)
row.addWidget(self.randomDelayCheck)
self.randomDelayNeg_edt = QSpinBox()
self.randomDelayNeg_edt.setPrefix('- ')
self.randomDelayNeg_edt.setSuffix(" secs")
self.randomDelayNeg_edt.setToolTip(
"Maximum random time (in seconds) subtracted from each vote timestamp"
)
self.randomDelayNeg_edt.setFixedWidth(100)
self.randomDelayNeg_edt.setMaximum(18000)
self.randomDelayNeg_edt.setValue(0)
row.addWidget(self.randomDelayNeg_edt)
self.randomDelayPos_edt = QSpinBox()
self.randomDelayPos_edt.setPrefix("+ ")
self.randomDelayPos_edt.setSuffix(" secs")
self.randomDelayPos_edt.setToolTip(
"Maximum random time (in seconds) added to each vote timestamp")
self.randomDelayPos_edt.setFixedWidth(100)
self.randomDelayPos_edt.setMaximum(18000)
self.randomDelayPos_edt.setValue(300)
row.addWidget(self.randomDelayPos_edt)
row.addStretch(1)
self.loadingLine = QLabel(
"<b style='color:red'>Vote Signatures.</b> Completed: ")
self.loadingLinePercent = QProgressBar()
self.loadingLinePercent.setMaximumWidth(200)
self.loadingLinePercent.setMaximumHeight(10)
self.loadingLinePercent.setRange(0, 100)
row.addWidget(self.loadingLine)
row.addWidget(self.loadingLinePercent)
self.loadingLine.hide()
self.loadingLinePercent.hide()
row.addStretch(1)
self.selectedPropLabel = QLabel("<em>0 proposals selected</em>")
row.addWidget(self.selectedPropLabel)
self.questionLabel = QLabel()
message = "Refresh proposals.\n"
message += "GREEN: proposal passing\n"
message += "WHITE: missing votes in order to pass\n"
message += "RED: proposal not passing\n"
message += "YELLOW: proposal expiring (last payment block)\n"
self.questionLabel.setToolTip(message)
row.addWidget(self.questionLabel)
layout.addLayout(row)
## -- ROW 4
row = QHBoxLayout()
self.voteYes_btn = QPushButton("Vote YES")
self.voteYes_btn.setToolTip("Vote YES on selected proposals")
row.addWidget(self.voteYes_btn)
self.voteAbstain_btn = QPushButton("Vote ABSTAIN")
self.voteAbstain_btn.setToolTip(
"Vote ABSTAIN on selected proposals [currently disabled]")
row.addWidget(self.voteAbstain_btn)
self.voteNo_btn = QPushButton("Vote NO")
self.voteNo_btn.setToolTip("Vote NO on selected proposals")
row.addWidget(self.voteNo_btn)
layout.addLayout(row)
def loadCacheData(self):
if self.caller.parent.cache.get("votingDelayCheck"):
negative_delay = self.caller.parent.cache.get("votingDelayNeg")
positive_delay = self.caller.parent.cache.get("votingDelayPos")
self.randomDelayCheck.setChecked(True)
self.randomDelayNeg_edt.setValue(negative_delay)
self.randomDelayPos_edt.setValue(positive_delay)
def setProposalBoxHeader(self):
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
item.setText("Name")
item.setToolTip("Proposal Name")
self.proposalBox.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
item.setText("Hash")
item.setToolTip("Proposal Hash")
self.proposalBox.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
item.setText("Link")
item.setToolTip("Link to Proposal Thread")
self.proposalBox.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
item.setText("PIV/month")
item.setToolTip("Monthly PIV Payment requested")
self.proposalBox.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
item.setText("Payments")
item.setToolTip("Remaining Payment Count / Total Payment Count")
self.proposalBox.setHorizontalHeaderItem(4, item)
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
item.setText("Network Votes")
item.setToolTip("Network Votes: YEAS/ABSTAINS/NAYS")
self.proposalBox.setHorizontalHeaderItem(5, item)
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
item.setText("My Votes")
item.setToolTip("My Votes: YEAS/ABSTAINS/NAYS")
self.proposalBox.setHorizontalHeaderItem(6, item)
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
item.setText("Details")
item.setToolTip("Check Proposal Details")
self.proposalBox.setHorizontalHeaderItem(7, item)
def loadIcons(self):
self.refresh_icon = QIcon(
os.path.join(self.caller.imgDir, 'icon_refresh.png'))
self.time_icon = QPixmap(
os.path.join(self.caller.imgDir, 'icon_clock.png'))
self.link_icon = QIcon(
os.path.join(self.caller.imgDir, 'icon_link.png'))
self.search_icon = QIcon(
os.path.join(self.caller.imgDir, 'icon_search.png'))
self.list_icon = QIcon(
os.path.join(self.caller.imgDir, 'icon_list.png'))
self.question_icon = QPixmap(
os.path.join(self.caller.imgDir, 'icon_question.png'))
def resetStatusLabel(self, message=None):
if message is None:
self.statusLabel.setText(
'<em><b style="color:purple">Loading proposals...</b></em>')
else:
self.statusLabel.setText(message)
self.statusLabel.setVisible(True)
import sys
import asyncio
import time
from PyQt5.QtWidgets import QApplication, QProgressBar
from quamash import QEventLoop, QThreadExecutor
app = QApplication(sys.argv)
loop = QEventLoop(app)
asyncio.set_event_loop(loop) # NEW must set the event loop
progress = QProgressBar()
progress.setRange(0, 99)
progress.show()
async def master():
await first_50()
with QThreadExecutor(1) as exec:
await loop.run_in_executor(exec, last_50)
# TODO announce completion?
async def first_50():
for i in range(50):
progress.setValue(i)
await asyncio.sleep(.01)
def last_50():
for i in range(50, 100):
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.init_widgets()
self.init_UI()
self.init_connection()
def init_widgets(self):
self.Display_Widget = Display_widget()
def init_UI(self):
self.setWindowIcon(QIcon("GUI-resourses/FT-icon.png"))
self.setWindowTitle("FT-ITK 简易三维医学数据可视化平台")
self.main_widget = QtWidgets.QWidget() # 创建窗口主部件
self.main_layout = QtWidgets.QGridLayout() # 创建主部件的网格布局
#self.main_widget.setObjectName('main_widget')
self.setCentralWidget(self.main_widget) # 设置窗口主部件
self.main_widget.setLayout(self.main_layout)
#self.setLayout(self.main_layout) # 设置窗口主部件布局为网格布局
self.left_widget = QtWidgets.QWidget() # 创建窗口左部件
self.left_layout = QtWidgets.QGridLayout()
self.left_widget.setLayout(self.left_layout)
self.main_layout.addWidget(self.left_widget, 0, 0)
self.main_layout.addWidget(self.Display_Widget, 0, 1)
self.left_treewidget = Drop_Tree_Widget(self.left_widget)
self.left_layout.addWidget(self.left_treewidget, 0, 0, 20, 10)
self.left_pbar_container_widget = QtWidgets.QWidget(self.left_widget)
self.pbar = QProgressBar(self.left_widget)
self.model_btn = QRadioButton(self.left_widget)
self.model_btn.setText("Seg")
self.left_layout.addWidget(self.pbar, 21, 1, 1, 9)
self.left_layout.addWidget(self.model_btn, 21, 0, 1, 1)
self.left_layout.setSpacing(20)
# self.left_layout.addWidget(self.left_pbar_container_widget)
# self.left_treewidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.pbar.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.model_btn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
#self.left_pbar_container_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# self.left_pbar_container_layout= QtWidgets.QHBoxLayout()
# self.left_pbar_container_widget.setLayout(self.left_pbar_container_layout)
# self.left_pbar_container_layout.addWidget(self.pbar)
# self.model_btn=SwitchBtn(self.left_pbar_container_widget)
# self.left_pbar_container_layout.addWidget(self.model_btn)
#self.pbar.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
def init_connection(self):
self.left_treewidget.file_text_signal.connect(self.handle_drop_file)
self.model_btn.toggled.connect(self.handle_model_btn_clicked)
self.Display_Widget.pbar_signal.connect(self.progress_bar_effect)
def handle_drop_file(self, file_path: str):
"""
activated when a file is dropped into treewidget
:param file_path: the path of the dropped file
:return:
"""
self.Display_Widget.load_data(file_path=file_path)
if self.model_btn.isChecked(): #do segmentation
self.Display_Widget.load_label_data()
self.Display_Widget.flash()
else:
pass
def handle_model_btn_clicked(self):
if self.model_btn.isChecked() == True: #do segmentation
self.Display_Widget.load_label_data()
self.Display_Widget.flash()
else:
self.pbar.setValue(0)
self.Display_Widget.clear_label()
self.Display_Widget.flash()
def FixSize(self):
self.setFixedSize(self.width(), self.height())
def progress_bar_effect(self): # just for show
for i in range(100):
self.pbar.setValue(i + 1)
time.sleep(0.01)
def mouseReleaseEvent(self, event):
if self.fIsReadOnly:
return
self.fLeftClickDown = False
QProgressBar.mouseReleaseEvent(self, event)
class WMain(QMainWindow, TgWai):
def __init__(self):
super().__init__()
self.wn_init()
def wn_init(self):
JC_LOG.info(self.tm_wai('Initializing ...'))
self.wv_i_nop = 0
self.setWindowTitle(GC_APP_NM)
self.resize(460, 145)
self.wu_cw = QWidget()
self.wu_lo = QGridLayout()
self.wu_cw.setLayout(self.wu_lo)
self.setCentralWidget(self.wu_cw)
def nf2_new_le():
fu2_le = QLineEdit()
fu2_le.setMinimumWidth(700)
fu2_le.setAlignment(Qt.AlignLeft)
fu2_le.setReadOnly(True)
return fu2_le
def nf2_ui_add_input(x_row):
fv2_row = x_row
self.wu_lb_i_pn = QLabel('Input path')
self.wu_le_i_pn = nf2_new_le()
self.wu_le_i_pn.setText(
QStandardPaths.writableLocation(
QStandardPaths.DesktopLocation))
self.wu_pb_i_fn = QPushButton('…')
self.wu_pb_i_fn.setMaximumWidth(25)
self.wu_lb_i_bn = QLabel('Input base name')
self.wu_le_i_bn = nf2_new_le()
self.wu_lb_i_nfo = QLabel('Input file info')
self.wu_le_i_nfo = nf2_new_le()
self.wu_lo.addWidget(self.wu_lb_i_pn, fv2_row, 0, 1, 1,
Qt.AlignRight)
self.wu_lo.addWidget(self.wu_le_i_pn, fv2_row, 1, 1, 3)
self.wu_lo.addWidget(self.wu_pb_i_fn, fv2_row, 4, 2, 1)
fv2_row += 1
self.wu_lo.addWidget(self.wu_lb_i_bn, fv2_row, 0, 1, 1,
Qt.AlignRight)
self.wu_lo.addWidget(self.wu_le_i_bn, fv2_row, 1, 1, 3)
fv2_row += 1
self.wu_lo.addWidget(self.wu_lb_i_nfo, fv2_row, 0, 1, 1,
Qt.AlignRight)
self.wu_lo.addWidget(self.wu_le_i_nfo, fv2_row, 1, 1, -1)
return fv2_row
def nf2_ui_add_hor_ln(x_row):
fv2_row = x_row
fu2_fm = QFrame()
fu2_fm.setGeometry(QRect(1, 1, 1, 1))
fu2_fm.setFrameShape(QFrame.HLine)
fu2_fm.setFrameShadow(QFrame.Sunken)
self.wu_lo.addWidget(fu2_fm, fv2_row, 0, 1, -1)
return fv2_row
def nf2_ui_add_config(x_row):
fv2_row = x_row
self.wu_lb_cfg = QLabel('Setup')
self.wu_hbl_cfg = QHBoxLayout()
self.wu_hbl_cfg.setSpacing(1)
def ff3_new_sb_repeat():
fu3_sb = QSpinBox()
fu3_sb.setMinimum(1)
fu3_sb.setMaximum(100_000)
fu3_sb.setValue(fu3_sb.minimum())
fu3_sb.setPrefix('repeat the PDF file ')
fu3_sb.setSuffix(' times')
fu3_sb.setSingleStep(1)
fu3_sb.setAlignment(Qt.AlignRight)
return fu3_sb
self.wu_sb_repeat = ff3_new_sb_repeat()
self.wu_hbl_cfg.addWidget(self.wu_sb_repeat)
self.wu_hbl_cfg.addItem(
QSpacerItem(1, 1, QSizePolicy.Expanding, QSizePolicy.Minimum))
self.wu_lo.addWidget(self.wu_lb_cfg, fv2_row, 0, 1, 1,
Qt.AlignRight)
self.wu_lo.addLayout(self.wu_hbl_cfg, fv2_row, 1, 1, -1)
return fv2_row
def nf2_ui_add_output(x_row):
fv2_row = x_row
self.wu_lb_o_pn = QLabel('Output path')
self.wu_le_o_pn = nf2_new_le()
self.wu_le_o_pn.setText(
gf_pj(
QStandardPaths.writableLocation(
QStandardPaths.DownloadLocation), 'TMPS'))
self.wu_lo.addWidget(self.wu_lb_o_pn, fv2_row, 0, 1, 1,
Qt.AlignRight)
self.wu_lo.addWidget(self.wu_le_o_pn, fv2_row, 1, 1, -1)
self.wu_lb_o_bn = QLabel('Output base name')
self.wu_le_o_bn = nf2_new_le()
self.wu_lb_o_nfo = QLabel('Output file info')
self.wu_le_o_nfo = nf2_new_le()
fv2_row += 1
self.wu_lo.addWidget(self.wu_lb_o_bn, fv2_row, 0, 1, 1,
Qt.AlignRight)
self.wu_lo.addWidget(self.wu_le_o_bn, fv2_row, 1, 1, -1)
fv2_row += 1
self.wu_lo.addWidget(self.wu_lb_o_nfo, fv2_row, 0, 1, 1,
Qt.AlignRight)
self.wu_lo.addWidget(self.wu_le_o_nfo, fv2_row, 1, 1, -1)
return fv2_row
def nf2_ui_add_process(x_row):
fv2_row = x_row
self.wu_lb_process = QLabel('Process')
self.wu_pgb = QProgressBar()
self.wu_pgb.setMinimum(0)
self.wu_pgb.setAlignment(Qt.AlignCenter)
self.wu_pb_do = QPushButton('Do')
self.wu_pb_do.setMaximumWidth(80)
self.wu_pb_do.setEnabled(False)
self.wu_te_log = QTextEdit()
self.wu_te_log.setFont(
QFontDatabase.systemFont(QFontDatabase.FixedFont))
self.wu_te_log.setReadOnly(True)
self.wu_te_log.setWordWrapMode(QTextOption.NoWrap)
self.wu_te_log.setMinimumHeight(250)
self.wu_lo.addWidget(self.wu_lb_process, fv2_row, 0, 1, 1,
Qt.AlignRight)
self.wu_lo.addWidget(self.wu_pgb, fv2_row, 1, 1, 2)
self.wu_lo.addWidget(self.wu_pb_do, fv2_row, 3, 1, -1,
Qt.AlignCenter)
fv2_row += 1
self.wu_lo.addWidget(self.wu_te_log, fv2_row, 1, 1, -1)
return fv2_row
nv_row = 0
nv_row = nf2_ui_add_input(nv_row) + 1
nv_row = nf2_ui_add_hor_ln(nv_row) + 1
nv_row = nf2_ui_add_config(nv_row) + 1
nv_row = nf2_ui_add_hor_ln(nv_row) + 1
nv_row = nf2_ui_add_output(nv_row) + 1
nv_row = nf2_ui_add_hor_ln(nv_row) + 1
nv_row = nf2_ui_add_process(nv_row) + 1
self.wu_lo.setColumnStretch(1, 1)
self.wu_pb_i_fn.clicked.connect(self.wn_pb_i_fn_clicked)
self.wu_sb_repeat.valueChanged.connect(self.wn_sb_repeat_value_changed)
self.wu_pb_do.clicked.connect(self.wn_pb_do_clicked)
def pp2_move_center():
pu2_cp = QDesktopWidget().availableGeometry().center()
pu2_fg = self.frameGeometry()
pu2_fg.moveCenter(pu2_cp)
self.move(pu2_fg.topLeft())
self.show()
pp2_move_center()
self.raise_()
def wn_pb_i_fn_clicked(self):
def np2_do():
pu2_i_fn = QFileDialog.getOpenFileName(self, 'Select PDF file',
self.wu_le_i_pn.text(),
'PDF file (*.pdf)')[0]
if not gf_if(pu2_i_fn): return
self.wn_log_clear()
self.wn_log_info(f'Requested file => {pu2_i_fn}')
self.wn_log_info('Getting total pages of the requested file ...')
self.wu_le_i_pn.setText(gf_pn(pu2_i_fn))
self.wv_i_nop = self.wm_pdf_nop(pu2_i_fn)
self.wu_le_i_bn.setText(gf_bn(pu2_i_fn))
self.wn_log_info(
f"Total pages of the requested file => {self.wv_i_nop:,d}")
self.wu_le_i_nfo.setText(f'{self.wv_i_nop:,d} page(s)')
self.wn_sb_repeat_value_changed()
try:
np2_do()
except:
gp_log_exception(self.wn_log_error, 'Following error occurs !!!',
gf_exception_to_list(), 30)
self.wn_log_error('Check your PDF file or this program logic !!!')
def wn_sb_repeat_value_changed(self):
if self.wv_i_nop < 1: return
nu_i_nop = self.wv_i_nop
nu_repeat = self.wu_sb_repeat.value()
nu_o_nop = nu_i_nop * nu_repeat
self.wu_le_o_bn.setText(
f'{ gf_jn ( self.wu_le_i_bn .text () ) }-(RepeatOneFile)-({nu_i_nop:d}ⅹ{nu_repeat:d})-{nu_o_nop:d}-pages.pdf'
)
self.wu_le_o_nfo.setText(
f'( {nu_i_nop:,d} ⅹ {nu_repeat:,d} ) => {nu_o_nop:,d} pages')
self.wu_pb_do.setEnabled(True)
def wn_pb_do_clicked(self):
nu_st = datetime.now()
nv_cancelled = False
gp_log_header(self.wn_log_info, 'Start processing ...', 23)
def np2_do():
pu2_w_lst = [self.wu_pb_i_fn, self.wu_sb_repeat, self.wu_pb_do]
def pp3_set_enabled(x3_bool):
for bu4_w in pu2_w_lst:
bu4_w.setEnabled(x3_bool)
try:
pp3_set_enabled(False)
bu3_o_fn = gf_pj(self.wu_le_o_pn.text(),
self.wu_le_o_bn.text())
self.wn_log_info(f'Output path => { gf_pn (bu3_o_fn) }')
self.wn_log_info(
f'Base name to generate => { gf_bn (bu3_o_fn) }')
if gf_if(bu3_o_fn):
self.wn_log_warn(
f'Oputput file is already exist in { gf_pn (bu3_o_fn) }'
)
bu4_overwrite = QMessageBox.question(
self, GC_APP_NM, 'Overwrite ?')
if bu4_overwrite == QMessageBox.No:
nonlocal nv_cancelled
nv_cancelled = True
return
JC_LOG.info('Make output path if not exist ...')
gp_mp(gf_pn(bu3_o_fn))
bu3_i_nop = self.wv_i_nop
bu3_repeat = self.wu_sb_repeat.value()
bu3_o_nop = bu3_i_nop * bu3_repeat
JC_LOG.info(f'Initializing progress bar ...')
self.wu_pgb.setMaximum(bu3_o_nop)
self.wu_pgb.setValue(0)
try:
self.wn_log_info('Opening input file ...')
bu4_i_doc = CjPdfDocument(
CjPdfReader(
gf_pj(self.wu_le_i_pn.text(),
self.wu_le_i_bn.text())))
self.wn_log_info('Opening output file ...')
self.wn_log_info(
'Writing output file ( may take a long time ) ...')
bu4_o_doc = CjPdfDocument(
CjPdfWriter(bu3_o_fn).setSmartMode(True))
bv4_o_nop_so_far = 0
bu4_cache = {}
for bu5_i_pg_no in range(1, bu3_i_nop + 1):
bu5_i_pg = bu4_i_doc.getPage(bu5_i_pg_no)
bu5_o_pg_sz = bu5_i_pg.getCropBox()
bu5_o_pg_cp = bu5_i_pg.copyAsFormXObject(bu4_o_doc)
bu4_cache[bu5_i_pg_no] = [bu5_o_pg_sz, bu5_o_pg_cp]
for bu5_iteration in range(1, bu3_repeat + 1):
self.wn_log_info(
f'New iteration {bu5_iteration} with page number {bv4_o_nop_so_far+1}'
)
for bu6_i_pg_no in range(1, bu3_i_nop + 1):
bu6_o_pg_sz = bu4_cache[bu6_i_pg_no][0]
bu6_o_pg_cp = bu4_cache[bu6_i_pg_no][1]
bu6_o_pg = bu4_o_doc.addNewPage(
CjPageSize(bu6_o_pg_sz))
CjPdfCanvas(bu6_o_pg).addXObject(bu6_o_pg_cp, 0, 0)
bv4_o_nop_so_far += 1
self.wu_pgb.setValue(bv4_o_nop_so_far)
GC_QAPP.processEvents()
finally:
bu4_o_doc.close()
bu4_i_doc.close()
finally:
pp3_set_enabled(True)
try:
np2_do()
except:
gp_log_exception(self.wn_log_error, 'Following error occurs !!!',
gf_exception_to_list(), 30)
self.wn_log_error('Check your PDF file or this program logic !!!')
else:
if nv_cancelled: self.wn_log_warn(f'Cancelled by user !!!')
else:
self.wn_log_info(
'Done processing => elapsed {} ...'.format(datetime.now() -
nu_st))
def wm_pdf_nop(self, x_fn): # (n)umber (o)f (p)ages
mu_doc = CjPdfDocument(CjPdfReader(x_fn))
mu_nop = mu_doc.getNumberOfPages()
mu_doc.close()
return mu_nop
def wn_log_clear(self):
self.wu_te_log.clear()
def wn_log_info(self, x_msg):
JC_LOG.info(x_msg)
self.wu_te_log.append(
f"<font color=black>[I] { self. wm_2_html (x_msg) }</font>")
def wn_log_warn(self, x_msg):
JC_LOG.warn(x_msg)
self.wu_te_log.append(
f"<font color=magenta>[W] { self. wm_2_html (x_msg) }</font>")
def wn_log_error(self, x_msg):
JC_LOG.error(x_msg)
self.wu_te_log.append(
f"<font color=red>[E] { self. wm_2_html (x_msg) }</font>")
def wm_2_html(self, x_msg):
nv_msg = re.sub(r'(?:\r\n|\r|\n)', '<br>', x_msg)
return nv_msg.replace(' ', ' ')
def __del__(self):
self.wn_fini()
def wn_fini(self):
JC_LOG.info(self.tm_wai('Finalizing ...'))
def closeEvent(self, x_ev):
JC_LOG.info(self.tm_wai('Closing ...'))
jp_request_exit(GC_EC_SUCCESS)
class WXForm(QWidget):
def __init__(self):
super().__init__()
self.files = None
self.initUI()
self.resize(550, 500)
def initUI(self):
self.createGridGroupBox()
self.createFileListBox()
self.createButtonBox()
mainLayout = QVBoxLayout()
hboxLayout = QHBoxLayout()
self.setWindowTitle('服务器软件')
hboxLayout.addWidget(self.gridGroupBox)
mainLayout.addLayout(hboxLayout)
mainLayout.addWidget(self.ButtonBox)
mainLayout.addWidget(self.FileListBox)
self.setLayout(mainLayout)
def createButtonBox(self):
self.ButtonBox = QGroupBox()
layout = QGridLayout()
self.select_path = QPushButton('选择文件')
self.select_path.clicked.connect(self.showDialog)
self.run_btn = QPushButton('上传')
self.run_btn.clicked.connect(self.start)
layout.addWidget(self.select_path, 0, 0, 1, 1)
layout.addWidget(self.run_btn, 0, 1, 1, 1)
self.ButtonBox.setLayout(layout)
def createFileListBox(self):
self.FileListBox = QGroupBox('上传文件')
layout = QGridLayout()
self.file_list = QListView()
self.cmodel = QStandardItemModel(self.file_list)
layout.addWidget(self.file_list, 1, 0)
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
layout.addWidget(self.pbar, 2, 0)
self.FileListBox.setLayout(layout)
def createGridGroupBox(self):
self.gridGroupBox = QGroupBox('服務器信息')
layout = QGridLayout()
address = QLabel('服务器地址')
self.address = QLineEdit('127.0.0.1:6379')
key = QLabel('数据库键名')
self.key = QLineEdit('title_license')
pwd = QLabel('服务器密码')
self.pwd = QLineEdit('tongna888')
self.pwd.setEchoMode(QLineEdit.Password)
layout.setSpacing(10)
layout.addWidget(address, 1, 0, 1, 1)
layout.addWidget(self.address, 1, 1, 1, 1)
layout.addWidget(key, 3, 0, 1, 1)
layout.addWidget(self.key, 3, 1, 1, 1)
layout.addWidget(pwd, 2, 0, 1, 1)
layout.addWidget(self.pwd, 2, 1, 1, 1)
layout.setColumnStretch(1, 10)
self.gridGroupBox.setLayout(layout)
def showDialog(self):
self.cmodel.clear()
self.files = QFileDialog.getOpenFileName(self, '选择文件', '', '*.csv')[0]
if self.files:
item = QStandardItem()
item.setText(self.files)
self.cmodel.appendRow(item)
self.file_list.setModel(self.cmodel)
def closeEvent(self, event):
event.accept()
try:
os._exit(5)
except Exception as e:
print(e)
def start(self):
host, port = self.address.text().split(':')
pool = redis.ConnectionPool(host=host,
port=port,
password=self.pwd.text())
red = redis.Redis(connection_pool=pool)
data = pd.read_csv(self.files)
self.length = len(data)
step = int(self.length / 100)
inds = {i for i in range(0, self.length, step)}
inds.add(self.length - 1)
self.pbar.setRange(0, self.length - 1)
for index, row in enumerate(data.values):
if index in inds:
self.pbar.setValue(index)
QApplication.processEvents()
red.sadd(self.key.text(), row[0].strip())
class RestoreIncBackupWindow(QWidget):
def __init__(self, incBackupList):
super().__init__()
self.setGeometry(200, 50, 300, 300)
self.setWindowTitle("Restore Incremental Backup")
self.incBackupList = incBackupList
global con
global cur
con = sqlite3.connect('backup/backupshistory.db')
cur = con.cursor()
self.layouts()
self.widgets()
def layouts(self):
self.mainLayout = QVBoxLayout()
self.topLayout = QVBoxLayout()
self.topLayout.setContentsMargins(20, 20, 20, 20)
self.bottomLayout = QHBoxLayout()
self.form = QFormLayout()
self.progeesBar = QProgressBar()
self.progeesBar.setHidden(True)
self.submitBtn = QPushButton("Submit")
self.submitBtn.clicked.connect(self.submitAction)
self.cancelBtn = QPushButton("Cancel")
self.cancelBtn.clicked.connect(self.cancelAction)
self.okBtn = QPushButton("Ok")
self.okBtn.clicked.connect(self.okAction)
self.okBtn.setHidden(True)
self.submitBtn.setFixedHeight(30)
self.cancelBtn.setFixedHeight(30)
self.okBtn.setFixedHeight(30)
self.submitBtn.setStyleSheet(
"color: #ecf0f1; background-color: #27ae60 ; border: 0px")
self.okBtn.setStyleSheet(
"color: #ecf0f1; background-color: #27ae60 ; border: 0px")
self.cancelBtn.setStyleSheet(
"color: #ecf0f1; background-color: #e74c3c; border: 0px")
self.bottomLayout.addWidget(self.submitBtn)
self.bottomLayout.addWidget(self.cancelBtn)
self.bottomLayout.addWidget(self.okBtn)
self.mainLayout.addLayout(self.topLayout)
self.mainLayout.addStretch()
self.mainLayout.addLayout(self.bottomLayout)
self.setLayout(self.mainLayout)
def widgets(self):
self.container = QHBoxLayout()
self.icon = QLabel('=>')
self.combobeginning = QComboBox()
self.comboend = QComboBox()
self.container.addWidget(self.combobeginning)
self.container.addWidget(self.icon)
self.container.addWidget(self.comboend)
self.container.addStretch()
self.alllevels = QCheckBox('All Levels')
self.alllevels.stateChanged.connect(self.alllevelsAction)
self.cretecombo()
self.topLayout.addWidget(self.txt)
self.topLayout.addWidget(self.combo)
self.topLayout.addWidget(self.alllevels)
self.lineEditrestoringDst = QLineEdit()
self.lineEditrestoringDst.setPlaceholderText(
'where you are going to restore your incremental backup')
self.text = QLabel('')
self.topLayout.addLayout(self.container)
self.topLayout.addWidget(QLabel('Restoring Destination : '))
self.topLayout.addWidget(self.lineEditrestoringDst)
self.topLayout.addWidget(self.text)
self.topLayout.addWidget(self.progeesBar)
def alllevelsAction(self):
if self.alllevels.isChecked():
self.combobeginning.setHidden(True)
self.comboend.setHidden(True)
self.icon.setHidden(True)
else:
self.combobeginning.setHidden(False)
self.comboend.setHidden(False)
self.icon.setHidden(False)
def cretecombo(self):
self.combo = QComboBox()
self.txt = QLabel('Chose Meta Name :')
self.combo.currentTextChanged.connect(self.updateLevels)
for item in self.incBackupList:
self.combo.addItem(item)
def updateLevels(self, value):
global cur
if self.alllevels.isChecked():
pass
else:
self.combobeginning.clear()
self.comboend.clear()
query = "SELECT level FROM IncrementalBackups WHERE metaname=? ORDER BY LEVEL ASC"
levels = cur.execute(query, (value, )).fetchall()
for item in levels:
self.combobeginning.addItem(str(item[0]))
self.comboend.addItem(str(item[0]))
def submitAction(self):
self.setCursor(Qt.WaitCursor)
global cur
try:
self.progeesBar.setHidden(False)
self.progeesBar.setMaximum(1)
self.progeesBar.setValue(0)
self.restoreincbackup()
except Exception:
QMessageBox.warning(
self, 'warning',
f"error occured during restoring these incremental backups\n")
else:
self.setCursor(Qt.ArrowCursor)
self.submitBtn.setHidden(True)
self.cancelBtn.setHidden(True)
self.okBtn.setHidden(False)
def okAction(self):
self.close()
def restoreincbackup(self):
global cur
try:
query = "SELECT metaname,name,dstpath FROM IncrementalBackups "
incbackups = cur.execute(query).fetchall()
restoreDst = self.lineEditrestoringDst.text()
begin = int(self.combobeginning.currentText())
end = int(self.comboend.currentText())
if self.alllevels.isChecked():
for incbackup in incbackups:
c = f"tar --extract --verbose --verbose --preserve-permissions --listed-incremental=/dev/null --file={incbackup[2]}/{incbackup[0]}/{incbackup[1]}.tar.gz --directory={restoreDst}"
subprocess.run(c, shell=True)
else:
for incbackup in incbackups[begin:end]:
c = f"tar --extract --verbose --verbose --preserve-permissions --listed-incremental=/dev/null --file={incbackup[2]}/{incbackup[0]}/{incbackup[1]}.tar.gz --directory={restoreDst}"
subprocess.run(c, shell=True)
except Exception as e:
self.text.setText(
f"error occured during restoring these backups\n{e}")
else:
self.text.setText("Backups restored succesfully!")
finally:
self.progeesBar.setValue(1)
def cancelAction(self):
self.close()
async def downloadObject(self, ipfsop, objConfig):
pBar = QProgressBar()
def onProgressValue(val):
if val in range(0, 50):
pBar.setStyleSheet('''
QProgressBar:horizontal {
border: 1px solid gray;
border-radius: 5px;
text-align: center;
}
QProgressBar::chunk:horizontal {
text-align: center;
background-color: #60cccf;
}
''')
else:
pBar.setStyleSheet('''
QProgressBar:horizontal {
border: 1px solid gray;
border-radius: 5px;
text-align: center;
}
QProgressBar::chunk:horizontal {
text-align: center;
background-color: #4b9fa2;
}
''')
pBar.setObjectName('downloadProgressBar')
pBar.valueChanged.connect(onProgressValue)
self.treeWidget().setItemWidget(self, self.COL_STATUS, pBar)
baseDir = self.baseDownloadDir()
chunkSize = objConfig.downloadChunkSize
log.debug(f'Downloading with chunk size {chunkSize}')
try:
async for result in ipfsop.client.core.getgen(
self.objdescr['path'], dstdir=str(baseDir),
chunk_size=chunkSize, sleept=0.1):
status, read, clength = result
if status == 0:
progress = (read * 100) / clength
pBar.setValue(progress)
elif status == 1:
break
await ipfsop.sleep(0.1)
except aioipfs.APIError as e:
# OK these setItemWidget() calls have got to go, this
# is not middle age here. Replace by signals asap.
self.treeWidget().setItemWidget(self, self.COL_STATUS, None)
self.status(f'IPFS error: {e.message}')
except Exception:
self.treeWidget().setItemWidget(self, self.COL_STATUS, None)
self.status('Error')
else:
pBar.setValue(100)
self.status('Downloaded')
self.treeWidget().setItemWidget(self, self.COL_STATUS, None)
hDir = baseDir.joinpath(self.stat['Hash'])
if self.objdescr['name']:
nDir = baseDir.joinpath(self.objdescr['name'])
else:
nDir = hDir
if nDir.exists():
return nDir
if hDir.exists():
hDir.replace(nDir)
return nDir
