class Ui_Widget(object):
""" Klasa definiująca GUI """
def setupUi(self, Widget):
# widgety rysujące kształty, instancje klasy Ksztalt
self.ksztalt1 = Ksztalt(self, Ksztalty.Polygon)
self.ksztalt2 = Ksztalt(self, Ksztalty.Ellipse)
self.ksztaltAktywny = self.ksztalt1
# przyciski CheckBox ###
uklad = QVBoxLayout() # układ pionowy
self.grupaChk = QButtonGroup()
for i, v in enumerate(('Kwadrat', 'Koło', 'Trójkąt', 'Linia')):
self.chk = QCheckBox(v)
self.grupaChk.addButton(self.chk, i)
uklad.addWidget(self.chk)
self.grupaChk.buttons()[self.ksztaltAktywny.ksztalt].setChecked(True)
# CheckBox do wyboru aktywnego kształtu
self.ksztaltChk = QCheckBox('<=')
self.ksztaltChk.setChecked(True)
uklad.addWidget(self.ksztaltChk)
# układ poziomy dla kształtów oraz przycisków CheckBox
ukladH1 = QHBoxLayout()
ukladH1.addWidget(self.ksztalt1)
ukladH1.addLayout(uklad)
ukladH1.addWidget(self.ksztalt2)
# koniec CheckBox ###
self.setLayout(ukladH1) # przypisanie układu do okna głównego
self.setWindowTitle('Widżety')
def add_radiobuttons(self, tab=False):
from PyQt5.QtWidgets import QRadioButton, QButtonGroup, QVBoxLayout
scrollLayout = QVBoxLayout()
buttonGroup = QButtonGroup()
buttongroup_results = {}
i = 1
if tab:
name = "tab"
i = 2
elif arguments.radiolist:
name = "radiolist"
elif arguments.menu:
name = "menu"
arglen = len(arguments.__dict__[name])
while i < arglen:
if arguments.radiolist:
radiobutton = QRadioButton(arguments.__dict__[name][i+1])
buttongroup_results[radiobutton] = arguments.__dict__[name][i]
if arguments.__dict__[name][i+2].lower() in ["true", "on"]:
radiobutton.setChecked(True)
i += 3
else:
radiobutton = QRadioButton(arguments.__dict__[name][i+1])
buttongroup_results[radiobutton] = arguments.__dict__[name][i]
if i == 1:
radiobutton.setChecked(True)
i += 2
scrollLayout.addWidget(radiobutton)
buttonGroup.addButton(radiobutton)
return scrollLayout, buttonGroup, buttongroup_results
class LabelButtonGroup(QWidget):
def __init__(self, label = '', buttons = {'UJ object reference value': 'Name to show'}):
super(LabelButtonGroup, self).__init__()
self.label = QLabel()
self.label.setText(label)
self.button_group = QButtonGroup()
self.buttons = {}
self.layout = QHBoxLayout()
self.layout.setContentsMargins(0,0,0,0)
self.layout.addWidget(self.label)
for button_key in buttons.keys():
self.buttons[button_key] = QRadioButton(buttons[button_key])
self.button_group.addButton(self.buttons[button_key])
self.layout.addWidget(self.buttons[button_key])
def show(self):
for button in self.buttons.values():
button.show()
self.label.show()
def hide(self):
for button in self.buttons.values():
button.hide()
self.label.hide()
def set_text(self, key):
if key != '':
self.buttons[key].setChecked(1)
def text(self):
return self.button_group.checkedButton().text()
def checked(self):
return self.button_group.checkedButton()
def intervalButtons(self):
widget = QGroupBox('Interval')
group = QButtonGroup(widget)
layout = QHBoxLayout()
widget.setLayout(layout)
def setInterval():
self.interval = group.checkedId()
interval = self.INTERVALS[self.interval][0]
self.updateTitle()
if interval:
self.progress.show()
self.progress.setMaximum(interval)
value = self.timer.seconds()
if value < interval:
self.progress.resume()
else:
self.progress.stop()
self.progress.setValue(min(interval, value))
else:
self.progress.hide()
for i, interval in enumerate(self.INTERVALS):
button = QPushButton(interval[1])
button.setCheckable(True)
button.clicked.connect(setInterval)
group.addButton(button, i)
layout.addWidget(button, 1 if i > 0 else 0)
return widget
class GSideToolbar(QWidget):
selectionChanged = pyqtSignal(str)
def __init__(self, buttons):
super().__init__()
self.selectedId = None
self.mainLayout = QVBoxLayout(self)
self.buttonGroup = QButtonGroup()
self.buttons = {}
for button in buttons:
b = QPushButton(button.name)
self.buttonGroup.addButton(b)
self.buttonGroup.setId(b, button.id)
self.buttons[button.id] = b
self.mainLayout.addWidget(b)
self.buttonGroup.buttonClicked.connect(self.buttonClicked)
self.mainLayout.addStretch()
def buttonState(self, state):
pass
def buttonClicked(self, button : QPushButton):
buttonId = self.buttonGroup.id(button)
buttonName = self.buttons[buttonId].text()
self.selectionChanged.emit(buttonName)
@staticmethod
def createButton(text, icon):
pass
class DyStockSelectAddColumnsDlg(QDialog):
def __init__(self, data, title, parent=None):
super().__init__(parent)
self._data = data
self._initUi(title)
def _initUi(self, title):
self.setWindowTitle('添加{0}列'.format(title))
# 控件
increaseColumnsLable = QLabel('基准日期几日{0}'.format(title))
self._increaseColumnsLineEdit = QLineEdit(','.join(self._data['days']) if self._data else '2,3,4,5,10' )
# 前 & 后
forwardRadioButton = QRadioButton('向前')
backwardRadioButton = QRadioButton('向后'); backwardRadioButton.setChecked(True)
# 添加到QButtonGroup
self._wardButtonGroup = QButtonGroup()
self._wardButtonGroup.addButton(forwardRadioButton, 1);
self._wardButtonGroup.addButton(backwardRadioButton, 2)
cancelPushButton = QPushButton('Cancel')
okPushButton = QPushButton('OK')
cancelPushButton.clicked.connect(self._cancel)
okPushButton.clicked.connect(self._ok)
# 布局
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(increaseColumnsLable, 0, 0, 1, 2)
grid.addWidget(self._increaseColumnsLineEdit, 1, 0, 1, 2)
grid.addWidget(forwardRadioButton, 2, 0)
grid.addWidget(backwardRadioButton, 2, 1)
grid.addWidget(okPushButton, 3, 1)
grid.addWidget(cancelPushButton, 3, 0)
self.setLayout(grid)
self.setMinimumWidth(QApplication.desktop().size().width()//5)
def _ok(self):
checkedButton = self._wardButtonGroup.checkedButton()
text = checkedButton.text()
self._data['backward'] = True if text == '向后' else False
self._data['days'] = [int(x) for x in self._increaseColumnsLineEdit.text().split(',')]
self.accept()
def _cancel(self):
self.reject()
def createGroupBox(self, layout):
group1 = QGroupBox(self)
group1.setTitle(self.tr("Clicking Behavior"))
group1.setMinimumHeight(150)
group1.setMaximumWidth(300)
layout.addWidget(group1)
vlayout1 = QVBoxLayout(group1)
buttonGroup = QButtonGroup(group1)
self.radiobutton1 = QRadioButton(group1)
self.radiobutton1.setText(self.tr("Single-click to open files and folders."))
self.radiobutton1.setChecked(True)
vlayout1.addWidget(self.radiobutton1)
self.radiobutton2 = QRadioButton(group1)
self.radiobutton2.setText(self.tr("Double-click to open files and folders."))
self.radiobutton2.setChecked(False)
vlayout1.addWidget(self.radiobutton2)
buttonGroup.addButton(self.radiobutton1)
buttonGroup.addButton(self.radiobutton2)
buttonGroup.buttonClicked.connect(self.folderClick)
group2 = QGroupBox(self)
group2.setTitle(self.tr("Button Order"))
group2.setMinimumHeight(150)
group2.setMaximumWidth(300)
layout.addWidget(group2)
vlayout2 = QVBoxLayout(group2)
buttonGroup2 = QButtonGroup(group2)
self.radiobutton3 = QRadioButton(group2)
self.radiobutton3.setText(self.tr("Right hand."))
self.radiobutton3.setChecked(True)
vlayout2.addWidget(self.radiobutton3)
self.radiobutton4 = QRadioButton(group2)
self.radiobutton4.setText(self.tr("Left hand."))
vlayout2.addWidget(self.radiobutton4)
buttonGroup2.addButton(self.radiobutton3)
buttonGroup2.addButton(self.radiobutton4)
buttonGroup2.buttonClicked.connect(self.mouseButton)
self.checkbox = QCheckBox(group2)
self.checkbox.setText(self.tr("Reverse scrolling."))
self.checkbox.clicked.connect(self.reverseScroll)
vlayout2.addWidget(self.checkbox)
def create_menu_buttons(self):
# Center on Player Button
button_center_player = QPushButton(
QIcon('maps/graphics/map_menu_center_player.png'),
''
)
button_center_player.setCheckable(True) # Make toggle button
button_center_player.setToolTip('Center on Player')
button_center_player.setObjectName('button_center_player')
# Center on Last Point Button
button_center_point = QPushButton(
QIcon('maps/graphics/map_menu_center_map.png'),
''
)
button_center_point.setCheckable(True) # Make toggle button
button_center_point.setToolTip('Center Normally')
button_center_point.setObjectName('button_center_point')
# Create Button Group for Exclusive Toggling
toggle_group = QButtonGroup(self)
toggle_group.addButton(button_center_player, 1)
toggle_group.addButton(button_center_point, 2)
toggle_group.buttonClicked.connect(self.center_button_toggled)
self.menu.addWidget(button_center_player)
self.menu.addWidget(button_center_point)
# Apply settings for current toggle
if self.settings.get_value('maps', 'center_on') == 'point':
button_center_point.setChecked(True)
else:
button_center_player.setChecked(True)
# Fit to Window Button
button_fit_window = QPushButton(
QIcon('maps/graphics/map_menu_fit_window.png'),
''
)
button_fit_window.setToolTip('Fit Map to Window')
button_fit_window.clicked.connect(self.fit_to_window)
self.menu.addWidget(button_fit_window, 0, Qt.AlignLeft)
# Maps Combo Box
self.combo_load_map = QComboBox(self)
# Need to setView otherwise CSS doesn't work
self.combo_load_map.setView(QListView())
self.combo_load_map.setToolTip('Manually Load Selected Map')
for map_name in sorted(self.map_pairs.keys(), key=str.lower):
self.combo_load_map.addItem(map_name)
self.combo_load_map.currentIndexChanged.connect(
self.load_map_from_combo
)
self.menu.addWidget(self.combo_load_map, 0, Qt.AlignLeft)
def initUI(self):
# create menus
menu.GuiMenu()
menu.WidgetMenu()
menu.SettingsMenu()
menu.LoggingMenu()
# main layout
mainVLayout = QVBoxLayout()
elementHLayouts = []
# top element: toolbar, status
t = QLabel("Toolbar")
s = QLabel("Status")
toolbarStatusHLayout = QHBoxLayout()
toolbarStatusHLayout.addWidget(t)
toolbarStatusHLayout.addWidget(s)
elementHLayouts.append(toolbarStatusHLayout)
# mid element: menu buttons
menubuttonsHLayout = QHBoxLayout()
stackedButtonsWidget = QStackedWidget()
buttonGroup = QButtonGroup(self)
buttonGroup.setExclusive(True)
for m in menu.Menu.menus:
btn = QPushButton(m.name)
btn.setCheckable(True)
btn.pressed.connect(lambda m=m: stackedButtonsWidget.setCurrentWidget(m))
menubuttonsHLayout.addWidget(btn)
buttonGroup.addButton(btn)
stackedButtonsWidget.addWidget(m)
elementHLayouts.append(menubuttonsHLayout)
# bot element: menu specific widgets
menuwidgetsHLayout = QHBoxLayout()
menuwidgetsHLayout.addWidget(stackedButtonsWidget)
elementHLayouts.append(menuwidgetsHLayout)
# click first button for defined initial state
if len(buttonGroup.buttons()) > 0:
buttonGroup.buttons()[0].click()
for l in elementHLayouts:
mainVLayout.addLayout(l)
self.setLayout(mainVLayout)
class DyStockTableSelectDlg(QDialog):
def __init__(self, data, dlgName):
super().__init__()
self._data = data
self._initUi(dlgName)
def _initUi(self, dlgName):
self.setWindowTitle(dlgName)
allRadioButton = QRadioButton('所有'); allRadioButton.setChecked(True)
highlightRadioButton = QRadioButton('高亮')
# 添加到QButtonGroup
self._buttonGroup = QButtonGroup()
self._buttonGroup.addButton(allRadioButton, 1);
self._buttonGroup.addButton(highlightRadioButton, 2)
cancelPushButton = QPushButton('Cancel')
okPushButton = QPushButton('OK')
cancelPushButton.clicked.connect(self._cancel)
okPushButton.clicked.connect(self._ok)
# 布局
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(allRadioButton, 1, 0)
grid.addWidget(highlightRadioButton, 1, 1)
grid.addWidget(okPushButton, 2, 1)
grid.addWidget(cancelPushButton, 2, 0)
self.setLayout(grid)
self.setMinimumWidth(QApplication.desktop().size().width()//5)
def _ok(self):
checkedButton = self._buttonGroup.checkedButton()
text = checkedButton.text()
self._data['all'] = True if text == '所有' else False
self.accept()
def _cancel(self):
self.reject()
class InputRadioGroup(QWidget):
"""Create an horizontal radio group"""
def __init__(self, parent=None, option_list=None, default_select=0):
super().__init__(parent=parent)
layout = QHBoxLayout(self)
self.group = QButtonGroup()
for idx, op in enumerate(option_list):
self.op = QRadioButton(_(op))
if idx == default_select:
self.op.setChecked(True)
layout.addWidget(self.op)
self.group.addButton(self.op)
self.setLayout(layout)
@pyqtProperty(str)
def currentItemData(self):
return str(abs(int(self.group.checkedId())) - 1)
def contextButtons(self):
widget = QGroupBox('Context')
group = QButtonGroup(widget)
layout = QHBoxLayout()
widget.setLayout(layout)
def setContext():
self.context = self.CONTEXTS[group.checkedId()]
self.updateTitle()
for i, context in enumerate(self.CONTEXTS):
button = QPushButton(context.title() if context else 'None')
button.setCheckable(True)
button.clicked.connect(setContext)
group.addButton(button, i)
layout.addWidget(button, 1 if i > 0 else 0)
return widget
class RadioGroup(object):
def __init__(self,
value_text_tuples: Iterable[Tuple[str, Any]],
default: Any = None) -> None:
# There's no reason for the caller to care about the internal IDs
# we use. So let's make them up here as positive integers.
self.default_value = default
if not value_text_tuples:
raise ValueError("No values passed to RadioGroup")
if contains_duplicates([x[0] for x in value_text_tuples]):
raise ValueError("Duplicate values passed to RadioGroup")
possible_values = [x[0] for x in value_text_tuples]
if self.default_value not in possible_values:
self.default_value = possible_values[0]
self.bg = QButtonGroup() # exclusive by default
self.buttons = []
self.map_id_to_value = {}
self.map_value_to_button = {}
for i, (value, text) in enumerate(value_text_tuples):
id_ = i + 1 # start with 1
button = QRadioButton(text)
self.bg.addButton(button, id_)
self.buttons.append(button)
self.map_id_to_value[id_] = value
self.map_value_to_button[value] = button
def get_value(self) -> Any:
buttongroup_id = self.bg.checkedId()
if buttongroup_id == NOTHING_SELECTED:
return None
return self.map_id_to_value[buttongroup_id]
def set_value(self, value: Any) -> None:
if value not in self.map_value_to_button:
value = self.default_value
button = self.map_value_to_button[value]
button.setChecked(True)
def add_buttons_to_layout(self, layout: QLayout) -> None:
for button in self.buttons:
layout.addWidget(button)
class CopyConfigDialog(ConfigDialog):
def __init__(self, mode=None):
super().__init__()
self.__initUI()
self.setSelectedCopyMode(mode)
def __initUI(self):
super().initUI()
self.setWindowTitle("画像コピー設定")
self.layout = QGridLayout()
self.radioGroup = QButtonGroup()
self.radioButton1 = QRadioButton("左右反転")
self.radioButton2 = QRadioButton("上下反転")
self.radioButton3 = QRadioButton("左右上下反転")
self.radioGroup.addButton(self.radioButton1)
self.radioGroup.addButton(self.radioButton2)
self.radioGroup.addButton(self.radioButton3)
self.layout.addWidget(self.radioButton1, 0, 0)
self.layout.addWidget(self.radioButton2, 1, 0)
self.layout.addWidget(self.radioButton3, 2, 0)
self.layout.addWidget(self.btnBox, 3, 1)
self.setLayout(self.layout)
"""コピー設定モードUI反映処理"""
def setSelectedCopyMode(self, mode):
if mode == Constant.LR_REVERSAL_MODE or mode is None:
self.radioButton1.setChecked(True)
elif mode == Constant.TB_REVERSAL_MODE:
self.radioButton2.setChecked(True)
else:
self.radioButton3.setChecked(True)
"""コピー設定モード取得処理"""
def getSelectedCopyMode(self):
if self.radioButton1.isChecked():
return Constant.LR_REVERSAL_MODE
elif self.radioButton2.isChecked():
return Constant.TB_REVERSAL_MODE
else:
return Constant.LRTB_REVERSAL_MODE
def __init__(self, result):
QDialog.__init__(self)
self.layout = QVBoxLayout(self)
self.result = result
observation_window = result.observation_window
group = QButtonGroup(self)
use_simu_duration = QRadioButton("Use entire simulation.")
use_simu_duration.setChecked(
observation_window[0] == 0
and observation_window[1] == result.model.duration)
group.addButton(use_simu_duration)
self.layout.addWidget(use_simu_duration)
use_custom = QRadioButton("Use a custom observation window:")
use_custom.setChecked(not use_simu_duration.isChecked())
group.addButton(use_custom)
self.layout.addWidget(use_custom)
self._slider = QxtSpanSliderWidget(
0, result.model.now() // result.model.cycles_per_ms, self)
self._slider.setSpan(
observation_window[0] // result.model.cycles_per_ms,
observation_window[1] // result.model.cycles_per_ms)
self._slider.setEnabled(use_custom.isChecked())
group.buttonClicked.connect(
lambda x: self._slider.setEnabled(x == use_custom))
self.layout.addWidget(self._slider)
buttons = QWidget(self)
buttons_layout = QHBoxLayout()
buttons.setLayout(buttons_layout)
buttons_layout.addStretch()
ok_button = QPushButton("Ok")
cancel_button = QPushButton("Cancel")
ok_button.clicked.connect(self.accept)
cancel_button.clicked.connect(self.reject)
buttons_layout.addWidget(ok_button)
buttons_layout.addWidget(cancel_button)
self.layout.addWidget(buttons)
def controlButtons(self):
widget = QWidget()
group = QButtonGroup(widget)
layout = QHBoxLayout()
widget.setLayout(layout)
startButton = QPushButton('Start')
startButton.setCheckable(True)
def onStart():
self.timer.start()
if self.progress.isPaused():
self.progress.resume()
startButton.clicked.connect(lambda: self.timer.start())
group.addButton(startButton)
layout.addWidget(startButton)
stopButton = QPushButton('Stop')
stopButton.setCheckable(True)
def onStop():
self.timer.stop()
self.progress.setPaused(True)
stopButton.clicked.connect(onStop)
group.addButton(stopButton)
layout.addWidget(stopButton)
resetButton = QPushButton('Reset')
def onReset():
self.timer.reset()
self.progress.resume()
resetButton.clicked.connect(onReset)
layout.addWidget(resetButton)
return widget
class HelpViewersPage(ConfigurationPageBase, Ui_HelpViewersPage):
"""
Class implementing the Help Viewers configuration page.
"""
def __init__(self):
"""
Constructor
"""
super(HelpViewersPage, self).__init__()
self.setupUi(self)
self.setObjectName("HelpViewersPage")
self.customViewerPicker.setMode(E5PathPickerModes.OpenFileMode)
self.helpViewerGroup = QButtonGroup()
self.helpViewerGroup.addButton(self.helpBrowserButton)
self.helpViewerGroup.addButton(self.qtAssistantButton)
self.helpViewerGroup.addButton(self.webBrowserButton)
self.helpViewerGroup.addButton(self.customViewerButton)
# set initial values
hvId = Preferences.getHelp("HelpViewerType")
# check availability of QtWebKit
try:
from PyQt5 import QtWebKit # __IGNORE_WARNING__
except ImportError:
# not available, reset help viewer to default
if hvId == 1:
hvId = Preferences.Prefs.helpDefaults["HelpViewerType"]
self.helpBrowserButton.setEnabled(False)
if hvId == 1:
self.helpBrowserButton.setChecked(True)
elif hvId == 2:
self.qtAssistantButton.setChecked(True)
elif hvId == 3:
self.webBrowserButton.setChecked(True)
else:
self.customViewerButton.setChecked(True)
self.customViewerPicker.setText(
Preferences.getHelp("CustomViewer"))
def save(self):
"""
Public slot to save the Help Viewers configuration.
"""
if self.helpBrowserButton.isChecked():
hvId = 1
elif self.qtAssistantButton.isChecked():
hvId = 2
elif self.webBrowserButton.isChecked():
hvId = 3
elif self.customViewerButton.isChecked():
hvId = 4
Preferences.setHelp("HelpViewerType", hvId)
Preferences.setHelp(
"CustomViewer",
self.customViewerPicker.text())
class HelpViewersPage(ConfigurationPageBase, Ui_HelpViewersPage):
"""
Class implementing the Help Viewers configuration page.
"""
def __init__(self):
"""
Constructor
"""
super(HelpViewersPage, self).__init__()
self.setupUi(self)
self.setObjectName("HelpViewersPage")
self.customViewerPicker.setMode(E5PathPickerModes.OpenFileMode)
self.helpViewerGroup = QButtonGroup()
self.helpViewerGroup.addButton(self.helpBrowserButton)
self.helpViewerGroup.addButton(self.qtAssistantButton)
self.helpViewerGroup.addButton(self.webBrowserButton)
self.helpViewerGroup.addButton(self.customViewerButton)
# set initial values
hvId = Preferences.getHelp("HelpViewerType")
if hvId == 1:
self.helpBrowserButton.setChecked(True)
elif hvId == 2:
self.qtAssistantButton.setChecked(True)
elif hvId == 3:
self.webBrowserButton.setChecked(True)
else:
self.customViewerButton.setChecked(True)
self.customViewerPicker.setText(
Preferences.getHelp("CustomViewer"))
def save(self):
"""
Public slot to save the Help Viewers configuration.
"""
if self.helpBrowserButton.isChecked():
hvId = 1
elif self.qtAssistantButton.isChecked():
hvId = 2
elif self.webBrowserButton.isChecked():
hvId = 3
elif self.customViewerButton.isChecked():
hvId = 4
Preferences.setHelp("HelpViewerType", hvId)
Preferences.setHelp(
"CustomViewer",
self.customViewerPicker.text())
class AddSystem(QDialog):
def __init__(self, parent=None, flags=QtCore.Qt.WindowFlags()):
super(AddSystem, self).__init__(parent=parent, flags=flags)
self.setWindowTitle(TEXT.DIALOG_TITLE)
self.setLayout(QVBoxLayout())
self.setupContent()
btnBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
btnBox.accepted.connect(self.accept)
btnBox.rejected.connect(self.reject)
btnBox.button(QDialogButtonBox.Ok).setText(TEXT.BTN_CREATE)
btnBox.button(QDialogButtonBox.Cancel).setText(TEXT.BTN_CANCEL)
self.layout().addWidget(btnBox)
def setupContent(self):
self.Content = QWidget(self)
self.layout().addWidget(self.Content)
self.FormLayout = QFormLayout()
self.Content.setLayout(self.FormLayout)
self.error = QtWidgets.QLabel(TEXT.LB_ERR_CORRECT_DATA,
objectName='error')
self.FormLayout.addWidget(self.error)
self.sys = QComboBox()
self.sys.addItem(TEXT.EXP)
# self.sys.addItem("Վեյբուլ")
# self.system.currentIndexChanged.connect(self.systemChanged)
self.sysType = [
(QRadioButton(TEXT.NOT_BACKUP, objectName='0'),
QRadioButton(TEXT.BACKUP, objectName='1')),
]
self.btnGroupOne = QButtonGroup(self)
self.btnGroupOne.addButton(self.sysType[0][0])
self.btnGroupOne.addButton(self.sysType[0][1])
self.sysType[0][0].setChecked(True)
self.groupOne = True
self.btnGroupOne.buttonClicked.connect(self.onClickedTypeOne)
self.FormLayout.addRow(QLabel(TEXT.LB_SYSTEM_TYPE), self.sys)
self.FormLayout.addRow(self.sysType[0][0], self.sysType[0][1])
def onClickedTypeOne(self, btn):
if btn.objectName() == '1' and self.groupOne:
self.groupOne = False
self.sysType.append((QRadioButton(TEXT.REPLACEMENT,
objectName='0'),
QRadioButton(TEXT.PERMANENT, objectName='1')))
self.btnGroupTwo = QButtonGroup(self)
self.btnGroupTwo.addButton(self.sysType[1][0])
self.btnGroupTwo.addButton(self.sysType[1][1])
self.sysType[1][1].setChecked(True)
self.FormLayout.addRow(self.sysType[1][0], self.sysType[1][1])
self.sysType.append((QRadioButton(TEXT.BY_ELEMENTS,
objectName='0'),
QRadioButton(TEXT.WHOLE, objectName='1')))
self.btnGroupThree = QButtonGroup(self)
self.btnGroupThree.addButton(self.sysType[2][0])
self.btnGroupThree.addButton(self.sysType[2][1])
self.sysType[2][0].setChecked(True)
self.groupThree = True
self.btnGroupThree.buttonClicked.connect(self.onClickedTypeThree)
self.FormLayout.addRow(self.sysType[2][0], self.sysType[2][1])
self.isSame = QCheckBox(TEXT.LB_THE_SAME_VALUE)
self.FormLayout.addWidget(self.isSame)
self.row = QLineEdit()
self.row.setPlaceholderText(TEXT.LEP_1_OR_MORE)
regexp = QtCore.QRegExp('^([1-9]\\d{0,1})$')
validator = QRegExpValidator(regexp) # QIntValidator(1, 15)
self.row.setValidator(validator)
self.row.textChanged.connect(self.check_state)
self.row.textChanged.emit(self.row.text())
self.FormLayout.addRow(QLabel(TEXT.LB_THE_BACKUP_ELM_COUNT),
self.row)
elif btn.objectName() == '0' and not self.groupOne:
self.groupOne = True
self.sysType = self.sysType[:1]
for i in range(5, self.FormLayout.count(), 2):
self.FormLayout.removeRow(3)
def onClickedTypeThree(self, btn):
if btn.objectName() == '1' and self.groupThree:
self.groupThree = False
self.col = QLineEdit()
self.col.setPlaceholderText(TEXT.LEP_2_OR_MORE)
regexp = QtCore.QRegExp('^([2-9]\\d{0,1})$')
validator = QRegExpValidator(regexp) # QIntValidator(1, 15)
self.col.setValidator(validator)
self.col.textChanged.connect(self.check_state)
self.col.textChanged.emit(self.row.text())
self.FormLayout.addRow(QLabel(TEXT.LB_THE_SYSTEM_ELM_COUNT),
self.col)
elif btn.objectName() == '0' and not self.groupThree:
self.groupThree = True
self.FormLayout.removeRow(7)
def CreateSystem(self):
switch = {0: self.exponential, 1: self.weibull}
return switch.get(self.System.SysConfig['system'])()
def exponential(self):
grid = QHBoxLayout()
wdg = QWidget()
wdg.setLayout(grid)
if self.System.SysConfig['isSame']:
rows = 0
else:
rows = self.System.SysConfig["row"]
self.System.lmds = []
for col in range(self.System.SysConfig["col"]):
f, w = QFormLayout(), QWidget()
w.setLayout(f)
grid.addWidget(w)
self.System.lmds.append([])
for row in range(rows + 1):
self.System.lmds[col].append(QLineEdit())
f.addRow(QLabel(f"λ[{row}][{col}]:"),
self.System.lmds[col][row])
self.System.layout().addWidget(wdg)
def weibull(self):
pass
@pyqtSlot()
def accept(self) -> None:
try:
isOne = int(self.btnGroupOne.checkedButton().objectName())
typeText = f'{self.sys.currentText()} համակարգ'
typeText += f'\n{self.btnGroupOne.checkedButton().text()}'
if isOne == 1:
row = int(self.row.text())
isTwo = self.btnGroupTwo.checkedButton().objectName()
isThree = self.btnGroupThree.checkedButton().objectName()
typeText += f'/{row}' \
f'\n{self.btnGroupThree.checkedButton().text()}'
if isThree == '1':
col = int(self.col.text())
typeText += f'/{col}'
typeText += f'\n{self.btnGroupTwo.checkedButton().text()}'
if self.isSame.isChecked():
typeText += f'\n{self.isSame.text()}'
except:
self.error.setText(TEXT.LB_ERR_WRONG_DATA)
self.error.show()
return
self.error.hide()
self.System = QWidget()
self.parent().Systems.layout().addWidget(self.System)
self.parent().SystemList.append(self.System)
form = QtWidgets.QFormLayout()
self.System.setLayout(form)
toolBar = QToolBar(self.System)
remove = QAction(TEXT.BTN_DELETE, self.System)
remove.triggered.connect(self.parent().RemoveCtrl)
toolBar.addAction(remove)
# edit = QAction('Խմբագրել', self.System)
# toolBar.addAction(edit)
form.addWidget(toolBar)
self.System.SysConfig = {
'system': self.sys.currentIndex(),
'row': row if isOne == 1 else 0,
'col': col if isOne == 1 and isThree == "1" else 1,
'typeOne': isOne,
'typeTwoAndThree': isTwo + isThree if isOne == 1 else None,
# 'typeThree': isThree if isOne else None,
'isSame': self.isSame.isChecked() if isOne == 1 else None,
}
# form.addWidget(QLabel(f'{self.System.SysConfig["system"][1]} համակարգ'))
# typeText = f'{self.System.SysConfig["typeOne"][1]}/{self.System.SysConfig["row"]}'
# if self.System.SysConfig["typeOne"][0]:
# typeText += f'\n{self.System.SysConfig["typeThree"][1]}/{self.System.SysConfig["col"]}' \
# f'\n{self.System.SysConfig["typeTwo"][1]}'
# if self.System.SysConfig["isSame"][0]:
# typeText += f'\n{self.System.SysConfig["isSame"][1]}'
form.addWidget(QLabel(typeText))
self.CreateSystem()
self.parent().calc.setEnabled(True)
self.close()
def check_state(self, *args, **kwargs):
sender = self.sender()
validator = sender.validator()
state = validator.validate(sender.text(), 0)[0]
if state == QValidator.Acceptable:
color = '#c4df9b' # green
elif state == QValidator.Intermediate:
color = '#fff79a' # yellow
else:
color = '#f6989d' # red
sender.setStyleSheet('QLineEdit { background-color: %s }' % color)
class DyStockSelectIndexMaKChartStatsDlg(QDialog):
def __init__(self, data, parent=None):
super().__init__(parent)
self._data = data
self._initUi()
def _initUi(self):
self.setWindowTitle('指数均线K线图统计')
# 控件
startDateLable = QLabel('开始日期')
self._startDateLineEdit = QLineEdit(datetime.now().strftime("%Y-%m-%d"))
endDateLable = QLabel('结束日期')
self._endDateLineEdit = QLineEdit(datetime.now().strftime("%Y-%m-%d"))
# 指数和股票代码
shIndexRadioButton = QRadioButton('上证指数'); shIndexRadioButton.setChecked(True)
szIndexRadioButton = QRadioButton('深证成指')
cybIndexRadioButton = QRadioButton('创业板指')
zxbIndexRadioButton = QRadioButton('中小板指')
hs300IndexRadioButton = QRadioButton('沪深300')
zz500IndexRadioButton = QRadioButton('中证500')
# 添加到QButtonGroup
self._stocksButtonGroup = QButtonGroup()
self._stocksButtonGroup.addButton(shIndexRadioButton, 1);
self._stocksButtonGroup.addButton(szIndexRadioButton, 2)
self._stocksButtonGroup.addButton(cybIndexRadioButton, 3)
self._stocksButtonGroup.addButton(zxbIndexRadioButton, 4)
self._stocksButtonGroup.addButton(hs300IndexRadioButton, 4)
self._stocksButtonGroup.addButton(zz500IndexRadioButton, 4)
cancelPushButton = QPushButton('Cancel')
okPushButton = QPushButton('OK')
cancelPushButton.clicked.connect(self._cancel)
okPushButton.clicked.connect(self._ok)
# 布局
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(startDateLable, 0, 0)
grid.addWidget(self._startDateLineEdit, 1, 0)
grid.addWidget(endDateLable, 0, 1)
grid.addWidget(self._endDateLineEdit, 1, 1)
grid.addWidget(shIndexRadioButton, 2, 0)
grid.addWidget(szIndexRadioButton, 2, 1)
grid.addWidget(cybIndexRadioButton, 3, 0)
grid.addWidget(zxbIndexRadioButton, 3, 1)
grid.addWidget(hs300IndexRadioButton, 4, 0)
grid.addWidget(zz500IndexRadioButton, 4, 1)
grid.addWidget(okPushButton, 5, 1)
grid.addWidget(cancelPushButton, 5, 0)
self.setLayout(grid)
def _getStockCode(self):
checkedButton = self._stocksButtonGroup.checkedButton()
text = checkedButton.text()
return DyStockCommon.getIndexSectorByName(text)
def _ok(self):
self._data['startDate'] = self._startDateLineEdit.text()
self._data['endDate'] = self._endDateLineEdit.text()
self._data['index'] = self._getStockCode()
self.accept()
def _cancel(self):
self.reject()
class DoublePanelWidget(QWidget):
def __init__(self, parent):
self.parent = parent
super().__init__(parent)
self.canvas = None
self.axes = None
self.qvb_options = QVBoxLayout()
self.qpb_show = QPushButton(' Refresh',
icon=self.style().standardIcon(
QStyle.SP_BrowserReload))
self.qbg_time_unit = QButtonGroup()
self.qcb_show_points = QCheckBox('Show Points')
self.qcb_show_legend = QCheckBox('Show Legend')
def create_layout(self):
figure = Figure((8.0, 6.0), dpi=100)
self.canvas = FigureCanvas(figure)
main_view = QWidget()
self.canvas.setParent(main_view)
self.axes = figure.add_subplot(111)
mpl_toolbar = NavigationToolbar(self.canvas, main_view)
self.qcb_show_points.setChecked(DISPLAY_POINTS)
self.qcb_show_points.stateChanged.connect(self.on_show)
self.qcb_show_legend.setChecked(DISPLAY_LEGEND)
self.qcb_show_legend.stateChanged.connect(self.on_show)
self.qpb_show.clicked.connect(self.on_show)
qvb_graph = QVBoxLayout()
qvb_graph.addWidget(self.canvas)
qvb_graph.addWidget(mpl_toolbar)
qw_graph = QWidget()
qw_graph.setLayout(qvb_graph)
qf_separator = QFrame()
qf_separator.setFrameShape(QFrame.HLine)
qhb_time_unit = QHBoxLayout()
for unit in TIME_UNITS.keys():
qrb_unit = QRadioButton(unit)
if self.parent.time_unit == unit:
qrb_unit.setChecked(True)
else:
qrb_unit.setChecked(False)
self.qbg_time_unit.addButton(qrb_unit)
qhb_time_unit.addWidget(qrb_unit)
self.qbg_time_unit.buttonClicked.connect(self.time_unit_changed)
self.qvb_options.addStretch(1)
self.qvb_options.addWidget(qf_separator)
self.qvb_options.addStretch(1)
self.qvb_options.addLayout(qhb_time_unit)
self.qvb_options.addWidget(self.qcb_show_points)
self.qvb_options.addWidget(self.qcb_show_legend)
self.qvb_options.addWidget(self.qpb_show)
qw_options = QWidget()
qw_options.setLayout(self.qvb_options)
splitter = QSplitter()
splitter.addWidget(qw_options)
splitter.addWidget(qw_graph)
splitter.setHandleWidth(10)
splitter.setCollapsible(0, False)
splitter.setCollapsible(1, False)
splitter.setStretchFactor(1, 1)
main_layout = QHBoxLayout()
main_layout.addWidget(splitter)
self.setLayout(main_layout)
def fill_variables_list(self):
pass
def fill_secondary_list(self):
pass
def set_default_selection(self):
pass
def on_show(self):
self.axes.clear()
self.axes.grid(True)
def time_unit_changed(self):
self.on_show()
def reach_changed(self):
pass
def get_unit_text(self):
return [
button.text() for button in self.qbg_time_unit.buttons()
if button.isChecked()
][0]
class MultplayerTournamentItem():
def __init__(self, y_pos, x_pos, startCheck: int):
tb_x_pos = x_pos
cb_x_pos = x_pos + 300
cb_x_step = 75
self.textbox = QLineEdit()
self.textbox.move(tb_x_pos, y_pos)
self.textbox.resize(280, 40)
font1 = self.textbox.font()
font1.setPointSize(20)
self.textbox.setFont(font1)
self.buttonGroup = QButtonGroup()
self.radiobutton1 = QRadioButton("Gray")
self.radiobutton2 = QRadioButton("Red")
self.radiobutton3 = QRadioButton("Yellow")
self.radiobutton4 = QRadioButton("Green")
font = QFont()
font.setStyleHint(QFont.Helvetica)
font.setPointSize(13)
font.setBold(True)
self.radiobutton1.setFont(font)
self.radiobutton2.setFont(font)
self.radiobutton3.setFont(font)
self.radiobutton4.setFont(font)
self.buttonGroup.addButton(self.radiobutton1)
self.buttonGroup.addButton(self.radiobutton2)
self.buttonGroup.addButton(self.radiobutton3)
self.buttonGroup.addButton(self.radiobutton4)
self.buttonGroup.setId(self.radiobutton1, 1)
self.buttonGroup.setId(self.radiobutton2, 2)
self.buttonGroup.setId(self.radiobutton3, 3)
self.buttonGroup.setId(self.radiobutton4, 4)
if startCheck is 1:
self.radiobutton1.setChecked(True)
elif startCheck is 2:
self.radiobutton2.setChecked(True)
elif startCheck is 3:
self.radiobutton3.setChecked(True)
else:
self.radiobutton4.setChecked(True)
y_plus = 7
self.radiobutton1.move(cb_x_pos, y_pos + y_plus)
self.radiobutton2.move(cb_x_pos + cb_x_step, y_pos + y_plus)
self.radiobutton3.move(cb_x_pos + cb_x_step * 2, y_pos + y_plus)
self.radiobutton4.move(cb_x_pos + cb_x_step * 3, y_pos + y_plus)
def hideAllWidgets(self):
self.textbox.hide()
self.radiobutton1.hide()
self.radiobutton2.hide()
self.radiobutton3.hide()
self.radiobutton4.hide()
def showAllWidgets(self):
self.textbox.show()
class IngresarPaciente(QDialog):
def __init__(self, parent=None):
super(IngresarPaciente,self).__init__(parent)
loadUi('registroPaciente.ui',self)
self.group()
regex= QtCore.QRegExp("[a-z-A-Z-_ _]+")
self.nombre_text.setValidator(QtGui.QRegExpValidator(regex))
self.documento_text.setValidator(QtGui.QIntValidator());
self.edad_text.setValidator(QtGui.QIntValidator());
self.estatura_text.setValidator(QtGui.QIntValidator());
self.peso_text.setValidator(QtGui.QIntValidator());
self.guardar.clicked.connect(self.guardarPaciente)
##Metodo para ingresar el paciente
def guardarPaciente(self):
cadena,cadena2,validar = self.validarIngreso()
if validar:
cedula = int(self.documento_text.text())
if m.existePaciente(cedula):
cadena = 'El paciente ya existe.'
self.confirmar.setText(cadena)
else:
nombre = self.nombre_text.text()
if self.femenino.isChecked():
sexo = 'Femenino'
else:
sexo = 'Masculino'
if self.radioA.isChecked():
sangre = 'A+'
elif self.radioA2.isChecked():
sangre = 'A-'
elif self.radioAB.isChecked():
sangre = 'AB+'
elif self.radioAB2.isChecked():
sangre = 'AB-'
elif self.radioB.isChecked():
sangre = 'B+'
elif self.radioB2.isChecked():
sangre = 'B-'
elif self.radioO.isChecked():
sangre = 'O+'
else:
sangre = 'O-'
edad = int(self.edad_text.text())
estatura = int(self.estatura_text.text())
peso = int(self.peso_text.text())
paciente = Paciente(nombre,cedula,sexo,sangre,edad,estatura,peso)
cadena = m.ingresarPaciente(paciente)
self.reset()
self.confirmar.setText(cadena)
else:
if cadena2 == 'Datos incorrectos: ':
self.confirmar.setText(cadena)
else:
if cadena == 'Se deben llenar los campos:':
self.confirmar.setText(cadena2)
else:
self.confirmar.setText(cadena+'\n'+cadena2)
##Metodos para validar
def validarIngreso(self):
cadena = 'Se deben llenar los campos:'
cadena2 = 'Datos incorrectos: '
cont = 0
if self.nombre_text.text() == '':
cont+=1
cadena+= ' - Nombre'
if self.documento_text.text() == '':
cont+=1
cadena+= ' - Documento'
elif int(self.documento_text.text())<=0:
cont+=1
cadena2+= ' - Documento'
if self.edad_text.text() == '':
cont+=1
cadena+= ' - Edad'
elif int(self.edad_text.text())<0 or int(self.edad_text.text())>200:
cont+=1
cadena2+= ' - Edad'
if self.estatura_text.text() == '':
cont+=1
cadena+= ' - Estatura'
elif int(self.estatura_text.text())<0 or int(self.estatura_text.text())>300:
cont+=1
cadena2+= ' - Estatura'
if self.peso_text.text() == '':
cont+=1
cadena+= ' - Peso'
elif int(self.peso_text.text())<0 or int(self.peso_text.text())>800:
cont+=1
cadena2+= ' - Peso'
if self.sangreisnotCheck():
cont+=1
cadena+= ' - Tipo de Sangre'
if self.sexoisnotCheck():
cont+=1
cadena+= ' - Sexo'
if cont == 0:
return cadena,cadena2,True
else:
return cadena,cadena2,False
def sexoisnotCheck(self):
if self.femenino.isChecked():
return False
if self.masculino.isChecked():
return False
return True
def sangreisnotCheck(self):
if self.radioA.isChecked():
return False
if self.radioA2.isChecked():
return False
if self.radioAB.isChecked():
return False
if self.radioAB2.isChecked():
return False
if self.radioB.isChecked():
return False
if self.radioB2.isChecked():
return False
if self.radioO.isChecked():
return False
if self.radioO2.isChecked():
return False
return True
##Metodos para resetear el sistema
def reset(self):
self.nombre_text.setText('')
self.documento_text.setText('')
self.estatura_text.setText('')
self.edad_text.setText('')
self.peso_text.setText('')
self.group.setExclusive(False)
self.radioA.setChecked(False)
self.radioA2.setChecked(False)
self.radioAB.setChecked(False)
self.radioAB2.setChecked(False)
self.radioB.setChecked(False)
self.radioB2.setChecked(False)
self.radioO.setChecked(False)
self.radioO2.setChecked(False)
self.group.setExclusive(True)
self.group2.setExclusive(False)
self.femenino.setChecked(False)
self.masculino.setChecked(False)
self.group2.setExclusive(True)
##
def group(self):
self.group = QButtonGroup()
self.group.addButton(self.radioA)
self.group.addButton(self.radioA2)
self.group.addButton(self.radioAB)
self.group.addButton(self.radioAB2)
self.group.addButton(self.radioB)
self.group.addButton(self.radioB2)
self.group.addButton(self.radioO)
self.group.addButton(self.radioO2)
self.group2 = QButtonGroup()
self.group2.addButton(self.femenino)
self.group2.addButton(self.masculino)
class ChromAbWidget(QWidget):
def __init__(self, parent=None):
super(ChromAbWidget, self).__init__(parent)
self.maxD = 20
self.deadZ = 5
self.isShapeRadial = True
self.isFalloffExp = True
self.direction = 100
self.interpolate = False
self.numThreads = 4
self.shapeInfo = QLabel("Shape and Direction:", self)
self.shapeChoice = QButtonGroup(self)
self.shapeBtn1 = QRadioButton("Radial")
self.shapeBtn2 = QRadioButton("Linear")
self.shapeChoice.addButton(self.shapeBtn1)
self.shapeChoice.addButton(self.shapeBtn2)
self.shapeBtn1.setChecked(True)
self.shapeBtn1.pressed.connect(self.changeShape1)
self.shapeBtn2.pressed.connect(self.changeShape2)
self.theDial = QDial()
self.theDial.setMinimum(0)
self.theDial.setMaximum(359)
self.theDial.setValue(100)
self.theDial.setWrapping(True)
self.theDial.valueChanged.connect(self.updateDial)
self.maxInfo = QLabel("Max Displacement: 20px", self)
self.maxDisplace = QSlider(Qt.Horizontal, self)
self.maxDisplace.setRange(1, 300)
self.maxDisplace.setValue(20)
self.maxDisplace.valueChanged.connect(self.updateMax)
self.falloffInfo = QLabel("Falloff:", self)
self.falloffChoice = QButtonGroup(self)
self.foBtn1 = QRadioButton("Exponential")
self.foBtn2 = QRadioButton("Linear")
self.falloffChoice.addButton(self.foBtn1)
self.falloffChoice.addButton(self.foBtn2)
self.foBtn1.setChecked(True)
self.foBtn1.pressed.connect(self.changeFalloff1)
self.foBtn2.pressed.connect(self.changeFalloff2)
self.deadInfo = QLabel("Deadzone: 5%", self)
self.deadzone = QSlider(Qt.Horizontal, self)
self.deadzone.setRange(0, 100)
self.deadzone.setValue(5)
self.deadzone.valueChanged.connect(self.updateDead)
self.biFilter = QCheckBox(
"Bilinear Interpolation (slow, but smooths colors)", self)
self.biFilter.stateChanged.connect(self.updateInterp)
self.threadInfo = QLabel(
"Number of Worker Threads (FOR ADVANCED USERS): 4", self)
self.workThreads = QSlider(Qt.Horizontal, self)
self.workThreads.setRange(1, 64)
self.workThreads.setValue(4)
self.workThreads.valueChanged.connect(self.updateThread)
vbox = QVBoxLayout()
vbox.addWidget(self.shapeInfo)
vbox.addWidget(self.shapeBtn1)
vbox.addWidget(self.shapeBtn2)
vbox.addWidget(self.theDial)
vbox.addWidget(self.maxInfo)
vbox.addWidget(self.maxDisplace)
vbox.addWidget(self.falloffInfo)
vbox.addWidget(self.foBtn1)
vbox.addWidget(self.foBtn2)
vbox.addWidget(self.deadInfo)
vbox.addWidget(self.deadzone)
vbox.addWidget(self.biFilter)
vbox.addWidget(self.threadInfo)
vbox.addWidget(self.workThreads)
self.setLayout(vbox)
self.show()
# Update labels and members
def updateMax(self, value):
self.maxInfo.setText("Max Displacement: " + str(value) + "px")
self.maxD = value
def updateDead(self, value):
self.deadInfo.setText("Deadzone: " + str(value) + "%")
self.deadZ = value
def changeShape1(self):
self.isShapeRadial = True
def changeShape2(self):
self.isShapeRadial = False
def changeFalloff1(self):
self.isFalloffExp = True
def changeFalloff2(self):
self.isFalloffExp = False
def updateDial(self, value):
self.direction = value
def updateInterp(self, state):
if state == Qt.Checked:
self.interpolate = True
else:
self.interpolate = False
def updateThread(self, value):
self.threadInfo.setText(
"Number of Worker Threads (FOR ADVANCED USERS): " + str(value))
self.numThreads = value
# Call into C library to process the image
def applyFilter(self, imgData, imgSize):
newData = create_string_buffer(imgSize[0] * imgSize[1] * 4)
dll = LibHandler.GetSharedLibrary()
dll.ApplyLinearAberration.argtypes = [
c_longlong, c_longlong, LinearFilterData, Coords, c_void_p,
c_void_p
]
dll.ApplyRadialAberration.argtypes = [
c_longlong, c_longlong, RadialFilterData, Coords, c_void_p,
c_void_p
]
imgCoords = Coords(imgSize[0], imgSize[1])
# python makes it hard to get a pointer to existing buffers for some reason
cimgData = c_char * len(imgData)
threadPool = []
interp = 0
if self.interpolate:
interp = 1
if self.isShapeRadial:
falloff = 0
if self.isFalloffExp:
falloff = 1
filterSettings = RadialFilterData(self.maxD, self.deadZ, falloff,
interp)
else:
filterSettings = LinearFilterData(self.maxD, self.direction,
interp)
idx = 0
for i in range(self.numThreads):
numPixels = (imgSize[0] * imgSize[1]) // self.numThreads
if i == self.numThreads - 1:
numPixels = (imgSize[0] * imgSize[1]
) - idx # Give the last thread the remainder
if self.isShapeRadial:
workerThread = Thread(target=dll.ApplyRadialAberration,
args=(
idx,
numPixels,
filterSettings,
imgCoords,
cimgData.from_buffer(imgData),
byref(newData),
))
else:
workerThread = Thread(target=dll.ApplyLinearAberration,
args=(
idx,
numPixels,
filterSettings,
imgCoords,
cimgData.from_buffer(imgData),
byref(newData),
))
threadPool.append(workerThread)
threadPool[i].start()
idx += numPixels
# Join threads to finish
for i in range(self.numThreads):
threadPool[i].join()
return bytes(newData)
app = QApplication([])
btn_OK = QPushButton('Ответить')
lb_Question = QLabel('Самый сложный вопрос в мире!')
RadioGroupBox = QGroupBox("Варианты ответов")
rbtn_1 = QRadioButton('Вариант 1')
rbtn_2 = QRadioButton('Вариант 2')
rbtn_3 = QRadioButton('Вариант 3')
rbtn_4 = QRadioButton('Вариант 4')
RadioGroup = QButtonGroup()
RadioGroup.addButton(rbtn_1)
RadioGroup.addButton(rbtn_2)
RadioGroup.addButton(rbtn_3)
RadioGroup.addButton(rbtn_4)
layout_ans1 = QHBoxLayout()
layout_ans2 = QVBoxLayout()
layout_ans3 = QVBoxLayout()
layout_ans2.addWidget(rbtn_1)
layout_ans2.addWidget(rbtn_2)
layout_ans3.addWidget(rbtn_3)
layout_ans3.addWidget(rbtn_4)
layout_ans1.addLayout(layout_ans2)
layout_ans1.addLayout(layout_ans3)
def __init__(self, parent=None, button_func=None, params=None):
super().__init__(parent, 'Data check', params)
self.button_func = button_func
path = os.path.abspath(os.path.dirname(__file__)) + '/static/'
# nr = min(5, data.shape[0])
nr = len(self.params.data5)
if params.lang == 'jp':
text = ('データの読み込み結果（先頭{n}行）を以下に示します．\n'
'データを正しく読み込めていることを確認してください．'.format(n=nr))
self.set_paragraph(
'データ読み込み結果の確認', text=text)
else:
text = ('First {n} rows of your data are shown below.\n'
'Confirm that the data was read correctly.'.format(n=nr))
self.set_paragraph(
'Check data', text=text)
table = NonScrollTable(self.inner)
table.setRowCount(nr)
table.setColumnCount(len(self.params.columns))
table.setHorizontalHeaderLabels([' ' + c + ' ' for c in self.params.columns])
for r in range(nr):
for c in range(len(self.params.columns)):
item = QTableWidgetItem('{:.4f}'.format(self.params.data5.iat[r, c]))
item.setFlags(Qt.ItemIsEnabled)
table.setItem(r, c, item)
table.setNonScroll()
self.vbox.addWidget(table)
# Text for type checking and objective variable setting
path1 = path + 'categorical'
text = self.get_text(path1)
if self.params.lang == 'en':
self.set_paragraph(
'Check type of variables and set objective variable',
text=text)
else:
self.set_paragraph('変数タイプの確認と目的変数の設定', text=text)
# htable = QTableWidget(self.inner)
htable = NonScrollTable(self.inner)
htable.setRowCount(len(self.params.columns))
htable.setColumnCount(4)
htable.setHorizontalHeaderLabels(
[' columns ', ' categorical ', ' numerical ', ' target '])
self.lst_cat = []
self.lst_num = []
self.lst_obj = []
self.obj_group = QButtonGroup(self.inner)
for c in range(len(self.params.columns)):
# col 1
item = QTableWidgetItem(self.params.columns[c])
item.setFlags(Qt.ItemIsEnabled)
htable.setItem(c, 0, item)
group = QButtonGroup(self.inner)
# col 2
htable.setCellWidget(
c, 1,
self.__make_cell(c, 'cat', self.params.col_types[c],
self.params.col_types_def[c]))
group.addButton(self.lst_cat[-1])
# col 3
htable.setCellWidget(
c, 2,
self.__make_cell(c, 'num', self.params.col_types[c],
self.params.col_types_def[c]))
group.addButton(self.lst_num[-1])
# col 4
htable.setCellWidget(
c, 3,
self.__make_cell(c, 'obj', self.params.col_types[c],
self.params.col_types_def[c]))
self.obj_group.addButton(self.lst_obj[-1])
self.obj_group.setId(self.lst_obj[-1], c)
htable.setNonScroll()
self.vbox.addWidget(htable)
if self.params.lang == 'jp':
self.txt_cnf = ('<font color="red">目的変数を１つ選択し，'
'targetの列にチェックをいれてください。')
if self.params.task.lower() == 'classification':
self.txt_cnf += '<br>目的変数はカテゴリ変数である必要があります。</font>'
else:
self.txt_cnf += '<br>目的変数は量的変数である必要があります。</font>'
else:
self.txt_cnf = ('<font color="red">Select one variable as target variable,'
'then set the column of "target" of the variable checked.')
if self.params.task.lower() == 'classification':
self.txt_cnf += '<br>Target variable must be a categorical variable.</font>'
else:
self.txt_cnf += '<br>Target variable must be a numerical variable.</font>'
self.lbl_cnf = QLabel(self.txt_cnf, self.inner)
self.vbox.addWidget(self.lbl_cnf)
self.vbox.addStretch(1)
self.btn = QPushButton('Next', self.inner)
self.btn.setStyleSheet('QPushButton{font: bold; font-size: 15pt; background-color: white;};')
if self.params.lang == 'en':
self.btn.clicked.connect(lambda: self.button_func('Overfitting'))
else:
self.btn.clicked.connect(lambda: self.button_func('過学習'))
if self.obj_group.checkedButton() is None:
self.btn.setEnabled(False)
else:
self.lbl_cnf.setText('<br>')
self.btn.setEnabled(True)
self.vbox.addWidget(self.btn)
class WeatherInput(QWidget):
"""
Weather parameter input for GUI. Contains selector on whether to scrape, import, or ignore with corresponding
windows for each based on current selection e.g. parameter input fields if scraping.
"""
def __init__(self):
super().__init__()
self.__init_weather()
self.__init_design()
def __init_weather(self):
self.layout = QVBoxLayout()
self.__scrape()
self.__import()
self.__none()
self.__revolver()
self.__selector()
self.layout.addWidget(self.selector)
self.layout.addWidget(self.revolver)
self.layout.addWidget(QLabel("Powered by the <a href=\"https://www.weatherbit.io/\">Weatherbit API</a>"))
self.setLayout(self.layout)
def __scrape(self):
input_fields = [("City", "text"), ("State", "text"), ("Country", "text"), ("Days", "text"),
("weatherbit.io Key", "text")]
input_defaults = {"City": "Cambridge", "State": "MA", "Country": "US", "Days": "14"}
self.scrape_layout, self.scrape_fields = basic_form_creator(input_fields, input_defaults)
# adding "Imperial Units" and "Save Weather" options as checkboxes in same row.
imperial = QCheckBox("Imperial Units")
imperial.setChecked(True) # default is checked
save = QCheckBox("Save")
self.scrape_fields["Imperial Units"] = imperial
self.scrape_fields["Save Weather"] = save
self.checkbox_layout = QHBoxLayout()
self.checkbox_layout.addWidget(imperial)
self.checkbox_layout.addWidget(save)
self.checkbox_layout.addStretch()
checkbox = QWidget()
checkbox.setLayout(self.checkbox_layout)
self.scrape_layout.addWidget(checkbox)
self.scrape = QWidget(self)
self.scrape.setLayout(self.scrape_layout)
def __import(self):
self.import_layout = QVBoxLayout()
button = QPushButton("Browse")
self.import_path = QPlainTextEdit()
font_height = self.import_path.fontMetrics().height()
num_rows = 5 # size of browse window, plenty of space to display full path
self.import_path.setFixedHeight(int(num_rows * font_height))
self.import_layout.addWidget(button, 0, Qt.AlignTop | Qt.AlignLeft) # align top-left corner
self.import_layout.addWidget(self.import_path, 0, Qt.AlignTop | Qt.AlignLeft)
button.clicked.connect(lambda: self.import_path.setPlainText(QFileDialog.getOpenFileName()[0]))
self.import_ = QWidget(self)
self.import_.setLayout(self.import_layout)
def __selector(self):
self.selector_layout = QHBoxLayout()
self.selector_button_group = QButtonGroup()
self.selector_button_group.setExclusive(True)
self.none_button = QRadioButton("None")
self.scrape_button = QRadioButton("Scrape")
self.import_button = QRadioButton("Import")
self.selector_button_group.addButton(self.none_button, 1)
self.selector_button_group.addButton(self.scrape_button, 2) # need 1-index because 0 means not found
self.selector_button_group.addButton(self.import_button, 3)
self.selector_layout.addWidget(self.none_button)
self.selector_layout.addWidget(self.scrape_button)
self.selector_layout.addWidget(self.import_button)
self.selector_layout.addStretch()
self.scrape_button.setChecked(True)
self.selector = QWidget(self)
self.selector.setLayout(self.selector_layout)
def __none(self):
self.none_ = QWidget()
def __revolver(self):
self.revolver = QStackedWidget()
self.revolver.addWidget(self.none_)
self.revolver.addWidget(self.scrape)
self.revolver.addWidget(self.import_)
self.revolver.setCurrentIndex(1) # default setting is scrape
def switch_window(self, button):
"""
Switch input fields based on current selection.
:param button: radio button of current selection
:return: nothing, mutates object
"""
self.revolver.setCurrentIndex(self.selector_button_group.id(button) - 1) # make up for 1-index
def __init_design(self):
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.setSpacing(0)
self.scrape_layout.setContentsMargins(0, 3, 11, 0) # effort to line up to TwilightInput
self.scrape_layout.setSpacing(5)
self.import_layout.setSpacing(10)
self.import_layout.addStretch(1)
self.selector_layout.setContentsMargins(0, 0, 0, 11)
self.checkbox_layout.setContentsMargins(0, 0, 0, 0)
self.scrape_layout.addStretch(25) # stretch large enough to move checkboxes close to other fields
self.default_border = self.scrape_fields["City"].styleSheet() # just get from any existing line edit
self.error_border = "border: 1px solid red;"
def request_trezor_init_settings(self, wizard, method, device_id):
vbox = QVBoxLayout()
next_enabled = True
devmgr = self.device_manager()
client = devmgr.client_by_id(device_id)
if not client:
raise Exception(_("The device was disconnected."))
model = client.get_trezor_model()
fw_version = client.client.version
# label
label = QLabel(_("Enter a label to name your device:"))
name = QLineEdit()
hl = QHBoxLayout()
hl.addWidget(label)
hl.addWidget(name)
hl.addStretch(1)
vbox.addLayout(hl)
# word count
gb = QGroupBox()
hbox1 = QHBoxLayout()
gb.setLayout(hbox1)
vbox.addWidget(gb)
gb.setTitle(_("Select your seed length:"))
bg_numwords = QButtonGroup()
word_counts = (12, 18, 24)
for i, count in enumerate(word_counts):
rb = QRadioButton(gb)
rb.setText(_("{:d} words").format(count))
bg_numwords.addButton(rb)
bg_numwords.setId(rb, i)
hbox1.addWidget(rb)
rb.setChecked(True)
# PIN
cb_pin = QCheckBox(_('Enable PIN protection'))
cb_pin.setChecked(True)
vbox.addWidget(WWLabel(RECOMMEND_PIN))
vbox.addWidget(cb_pin)
# "expert settings" button
expert_vbox = QVBoxLayout()
expert_widget = QWidget()
expert_widget.setLayout(expert_vbox)
expert_widget.setVisible(False)
expert_button = QPushButton(_("Show expert settings"))
def show_expert_settings():
expert_button.setVisible(False)
expert_widget.setVisible(True)
expert_button.clicked.connect(show_expert_settings)
vbox.addWidget(expert_button)
# passphrase
passphrase_msg = WWLabel(PASSPHRASE_HELP_SHORT)
passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
passphrase_warning.setStyleSheet("color: red")
cb_phrase = QCheckBox(_('Enable passphrases'))
cb_phrase.setChecked(False)
expert_vbox.addWidget(passphrase_msg)
expert_vbox.addWidget(passphrase_warning)
expert_vbox.addWidget(cb_phrase)
# ask for recovery type (random word order OR matrix)
bg_rectype = None
if method == TIM_RECOVER and not model == 'T':
gb_rectype = QGroupBox()
hbox_rectype = QHBoxLayout()
gb_rectype.setLayout(hbox_rectype)
expert_vbox.addWidget(gb_rectype)
gb_rectype.setTitle(_("Select recovery type:"))
bg_rectype = QButtonGroup()
rb1 = QRadioButton(gb_rectype)
rb1.setText(_('Scrambled words'))
bg_rectype.addButton(rb1)
bg_rectype.setId(rb1, RECOVERY_TYPE_SCRAMBLED_WORDS)
hbox_rectype.addWidget(rb1)
rb1.setChecked(True)
rb2 = QRadioButton(gb_rectype)
rb2.setText(_('Matrix'))
bg_rectype.addButton(rb2)
bg_rectype.setId(rb2, RECOVERY_TYPE_MATRIX)
hbox_rectype.addWidget(rb2)
# no backup
cb_no_backup = None
if method == TIM_NEW:
cb_no_backup = QCheckBox(f'''{_('Enable seedless mode')}''')
cb_no_backup.setChecked(False)
if (model == '1' and fw_version >= (1, 7, 1)
or model == 'T' and fw_version >= (2, 0, 9)):
cb_no_backup.setToolTip(SEEDLESS_MODE_WARNING)
else:
cb_no_backup.setEnabled(False)
cb_no_backup.setToolTip(_('Firmware version too old.'))
expert_vbox.addWidget(cb_no_backup)
vbox.addWidget(expert_widget)
wizard.exec_layout(vbox, next_enabled=next_enabled)
return TrezorInitSettings(
word_count=word_counts[bg_numwords.checkedId()],
label=name.text(),
pin_enabled=cb_pin.isChecked(),
passphrase_enabled=cb_phrase.isChecked(),
recovery_type=bg_rectype.checkedId() if bg_rectype else None,
no_backup=cb_no_backup.isChecked() if cb_no_backup else False,
)
class myApplication(QDialog):
def __init__(self, parent = None):
super(myApplication,self).__init__()
self.pallete = QApplication.palette(self)
self.group_layout = None
self.create_controls()
self.create_charts()
self.tabs = QTabWidget()
self.main_tab = QWidget()
self.results_tab = QWidget()
self.create_displayer()
self.application_layout = QGridLayout()
self.application_layout.addWidget(self.controlGroup,0,0)
self.graphGroup = QGroupBox('Graphs')
layout = QGridLayout()
layout.addWidget(self.actual_score_chart,0,0)
layout.addWidget(self.score_avg,0,1)
layout.addWidget(self.score_avg_100,0,2)
layout.addWidget(self.score_avg_report,1,0)
layout.addWidget(self.steps_chart,1,1)
layout.addWidget(self.egreedy_chart,1,2)
self.graphGroup.setLayout(layout)
self.graphGroup.setEnabled(False)
self.application_layout.addWidget(self.graphGroup,0,1)
self.create_progress_bar()
self.main_tab.setLayout(self.application_layout)
self.tabs.addTab(self.main_tab, 'Application')
self.tabs.addTab(self.results_tab, 'Results displayer')
self.main_layout = QGridLayout()
self.main_layout.addWidget(self.tabs)
self.setLayout(self.main_layout)
self.setWindowTitle('Diplomova praca Jakub Sarina')
self.resize(1900,960)
self.show()
def create_buttons(self):
self.start = QPushButton('Start training session')
self.stop = QPushButton('Stop')
self.start.clicked.connect(self.on_click_start)
self.stop.clicked.connect(self.on_click_stop)
self.stop.setDisabled(True)
self.button_layout = QGridLayout()
self.button_layout.addWidget(self.stop,0,0)
self.button_layout.addWidget(self.start,0,1)
def on_click_start(self):
config = {}
config['learn_rate'] = float(self.learn_rate.text())
config['num_o_ep'] = int(self.num_o_ep.text())
config['gamma'] = float(self.gamma.text())
config['egreedy'] = float(self.egreedy.text())
config['decay'] = float(self.decay.text())
config['egreedy_final'] = float(self.egreedy_final.text())
config['score_to_achieve'] = int(self.score_to_achieve.text())
config['report_interval'] = int(self.report_interval.text())
if self.number_o_hidden_layers.text() != None or self.number_o_hidden_layers.text() != '':
config['number_o_hidden_layers'] = int(self.number_o_hidden_layers.text())
else:
config['number_o_hidden_layers'] = 0
config['hidden_layers'] = [int(i.text()) for i in self.hidden_layers]
config['memory_size'] = int(self.memory_size.text())
config['batch_size'] = int(self.batch_size.text())
config['update_target_frequency'] = int(self.update_target_frequency.text())
config['clip_err'] = self.clip_err.isChecked()
config['double_DQN'] = self.double_DQN.isChecked()
config['DQN'] = self.DQN.isChecked()
config['dueling'] = self.dueling.isChecked()
config['rendering_enabled'] = self.rendering_enabled.isChecked()
config['load_weights_enabled'] = self.load_weights_enabled.isChecked()
config['save_weights_enabled'] = self.save_weights_enabled.isChecked()
config['variable_updating_enabled'] = self.variable_updating_enabled.isChecked()
config['stats_output_file'] = self.save_data_filename.text()
config['use_static'] = self.use_static.isChecked()
if self.load_weights_enabled.isChecked() == True:
config['load_weights_filename'] = self.load_weights_filename.text()
if self.rendering_enabled.isChecked() == True:
config['render_frequency'] = int(self.render_frequency.text())
if self.save_weights_enabled.isChecked() == True:
config['weights_saving_frequency'] = int(self.weight_saving_frequency.text())
config['save_weights_filename'] = self.save_weights_filename.text()
if self.variable_updating_enabled.isChecked() == True:
config['update_target_frequency_base'] = int(self.update_target_frequency_base.text())
config['update_target_frequency_multiplicator'] = float(self.update_target_frequency_multiplicator.text())
config['update_target_frequency_limit'] = int(self.update_target_frequency_limit.text())
self.score_avg_report.setTitle('Average score last '+self.report_interval.text()+' episodes')
self.stop.setDisabled(False)
self.deamon = RefreshDeamon(config)
self.deamon.signal.connect(self.callback)
self.reset_progress_bar()
self.reset_charts()
self.progress_bar_layout.setEnabled(True)
self.deamon.start()
def on_click_stop(self):
self.deamon.stop()
self.stop.setDisabled(True)
self.progress_bar_layout.setEnabled(False)
def create_progress_bar(self):
self.progress_bar = QProgressBar()
self.progress_bar.setGeometry(0,0,1895,30)
self.progress_bar.setTextVisible(True)
self.progress_bar.setFormat('% to win')
self.progress_bar.setAlignment(Qt.AlignCenter)
self.progress_bar_layout = QGridLayout()
self.progress_bar_layout.addWidget(self.progress_bar, 0, 0, 1, -1)
self.episode_label = QLabel()
self.run_time_label = QLabel()
self.frames_label = QLabel()
self.memory_level_label = QLabel()
self.is_solved_label = QLabel()
self.progress_bar_layout.addWidget(self.episode_label, 1,0)
self.progress_bar_layout.addWidget(self.run_time_label,1,1)
self.progress_bar_layout.addWidget(self.frames_label, 1,2)
self.progress_bar_layout.addWidget(self.memory_level_label, 1,3)
self.progress_bar_layout.addWidget(self.is_solved_label, 1,4)
self.application_layout.addLayout(self.progress_bar_layout,1,0,1,-1)
self.progress_bar_layout.setEnabled(False)
def reset_progress_bar(self):
self.episode_label.setText('Episode: 0/' + self.num_o_ep.text())
self.run_time_label.setText('Run time: 0 s')
self.frames_label.setText('Frames total: 0')
self.memory_level_label.setText('Replay memory filling level: 0/' + self.memory_size.text())
self.is_solved_label.setText('Solved: False')
self.progress_bar.setMaximum(int(self.score_to_achieve.text()))
self.progress_bar.setValue(0)
def update_progress_bar_layout(self,episode,frames_total,memory_level,solved,score):
self.episode_label.setText('Episode: {}/{}'.format(episode, self.num_o_ep.text()))
self.run_time_label.setText('Run Time')
self.frames_label.setText('Frames total: ' + frames_total)
self.memory_level_label.setText('Replay memory filling level: {}/{}'.format(memory_level, self.memory_size.text()))
self.is_solved_label.setText('Solved: ' + solved)
self.progress_bar.setValue(float(score))
def create_controls(self):
self.controlGroup = QGroupBox('Controls')
self.learn_rate = QLineEdit('0.001')
self.learn_rate_label = QLabel('Learning rate:')
self.num_o_ep = QLineEdit('20000')
self.num_o_ep_label = QLabel('Number of episodes')
self.gamma = QLineEdit('0.99')
self.gamma_label = QLabel('Gamma:')
self.egreedy = QLineEdit('0.99')
self.egreedy_label = QLabel('Starting Egreedy:')
self.decay = QLineEdit('0.999')
self.decay_label = QLabel('Egreedy decay:')
self.egreedy_final = QLineEdit('0.01')
self.egreedy_final_label = QLabel('Final Egreedy:')
self.score_to_achieve = QLineEdit('200')
self.score_to_achieve_label = QLabel('Score to win:')
self.report_interval = QLineEdit('10')
self.report_interval_label = QLabel('Report interval:')
self.number_o_hidden_layers = QLineEdit('2')
self.number_o_layers_label = QLabel('Number of hidden layers:')
self.use_static = QCheckBox('Use static model')
self.use_static.stateChanged.connect(lambda x: self.use_static_model(self.use_static.isChecked()))
self.hidden_layers = []
self.number_o_hidden_layers.textChanged.connect(lambda x: self.create_network_controls(int(self.number_o_hidden_layers.text()) if self.number_o_hidden_layers.text() != '' else 0))
self.memory_size = QLineEdit('600000')
self.memory_size_label = QLabel('Replay memory size:')
self.batch_size = QLineEdit('64')
self.batch_size_label = QLabel('Batch size')
self.update_target_frequency = QLineEdit('200')
self.update_target_frequency_label = QLabel('Update target network frequency:')
self.clip_err = QCheckBox('Error clipping enabled:')
self.clip_err.setChecked(False)
self.double_DQN = QRadioButton('Double DQN approach')
self.double_DQN.setChecked(False)
self.DQN = QRadioButton('DQN approach')
self.DQN.setChecked(True)
self.approach_group = QButtonGroup()
self.approach_group.addButton(self.DQN)
self.approach_group.addButton(self.double_DQN)
self.dueling = QCheckBox('use Dueling NN architecture')
self.dueling.setChecked(False)
self.rendering_enabled = QCheckBox('Enable rendering')
self.rendering_enabled.setChecked(False)
self.variable_updating_enabled = QCheckBox('Enable variable target updating:')
self.variable_updating_enabled.setChecked(False)
self.variable_updating_enabled.stateChanged.connect(self.variable_updating_changed)
self.rendering_enabled.stateChanged.connect(self.rendering_changed)
self.load_weights_enabled = QCheckBox('Enable loading weights')
self.load_weights_enabled.setChecked(False)
self.load_weights_enabled.stateChanged.connect(self.load_weights_changed)
self.save_weights_enabled = QCheckBox('Enable saving weights')
self.save_weights_enabled.setChecked(False)
self.save_data_filename_label = QLabel('Data storage filename')
self.save_data_filename = QLineEdit('Data_output.txt')
self.save_weights_enabled.stateChanged.connect(self.save_weights_changed)
self.create_control_layout()
def use_static_model(self, value):
self.number_o_hidden_layers.setDisabled(value)
self.create_network_controls(2)
def create_control_layout(self):
layout = QGridLayout()
layout.addWidget(self.learn_rate_label, 0, 0)
layout.addWidget(self.learn_rate, 0, 1)
layout.addWidget(self.num_o_ep_label, 1, 0)
layout.addWidget(self.num_o_ep, 1, 1)
layout.addWidget(self.gamma_label, 2, 0)
layout.addWidget(self.gamma, 2, 1)
layout.addWidget(self.egreedy_label, 3, 0)
layout.addWidget(self.egreedy, 3, 1)
layout.addWidget(self.decay_label, 4, 0)
layout.addWidget(self.decay, 4, 1)
layout.addWidget(self.egreedy_final_label, 5, 0)
layout.addWidget(self.egreedy_final, 5, 1)
layout.addWidget(self.score_to_achieve_label, 6, 0)
layout.addWidget(self.score_to_achieve, 6, 1)
layout.addWidget(self.report_interval_label, 7, 0)
layout.addWidget(self.report_interval, 7, 1)
layout.addWidget(self.number_o_layers_label, 8, 0)
layout.addWidget(self.number_o_hidden_layers, 8, 1)
layout.addWidget(self.use_static, 9, 1)
self.network_layout = QGridLayout()
self.create_network_controls(2)
layout.addLayout(self.network_layout, 10, 0, 1, -1)
layout.addWidget(self.memory_size_label, 11, 0)
layout.addWidget(self.memory_size, 11, 1)
layout.addWidget(self.batch_size_label, 12, 0)
layout.addWidget(self.batch_size, 12, 1)
layout.addWidget(self.update_target_frequency_label, 13, 0)
layout.addWidget(self.update_target_frequency, 13, 1)
layout.addWidget(self.save_data_filename_label, 14, 0)
layout.addWidget(self.save_data_filename, 14, 1)
layout.addWidget(self.clip_err, 15, 0)
layout.addWidget(self.DQN, 16, 0)
layout.addWidget(self.double_DQN, 16, 1)
layout.addWidget(self.dueling, 17, 0)
layout.addWidget(self.rendering_enabled, 18, 0)
layout.addWidget(self.variable_updating_enabled, 20, 0)
layout.addWidget(self.save_weights_enabled, 22, 0)
layout.addWidget(self.load_weights_enabled, 24, 0)
self.save_layout = QGridLayout()
self.rendering_layout = QGridLayout()
self.load_layout = QGridLayout()
self.variable_updating_layout = QGridLayout()
layout.addLayout(self.save_layout, 23, 0, 1, -1)
layout.addLayout(self.load_layout, 25, 0, 1, -1)
layout.addLayout(self.rendering_layout, 19, 0, 1, -1)
layout.addLayout(self.variable_updating_layout, 21, 0, 1, -1)
self.create_buttons()
layout.addLayout(self.button_layout,26,0,1,-1)
self.group_layout = layout
self.controlGroup.setLayout(self.group_layout)
def create_network_controls(self, number):
# if (self.number_o_hidden_layers.text() == '' or self.number_o_hidden_layers.text() is None):
# for i in range(self.network_layout.count()):
# tmp = self.network_layout.itemAt(0).widget()
# tmp.hide()
# self.network_layout.removeWidget(tmp)
# del tmp
# self.hidden_layers = []
# self.network_layout.update()
# return
hidden_layers = []
for i in range(self.network_layout.count()):
tmp = self.network_layout.itemAt(0).widget()
tmp.hide()
self.network_layout.removeWidget(tmp)
del tmp
for i in range(number):
if len(self.hidden_layers) > 0:
hidden_layers.append(QLineEdit(self.hidden_layers[i].text()))
else:
hidden_layers.append(QLineEdit())
name = 'Hidden layer ' + (str(i+1)) + ': '
self.network_layout.addWidget(QLabel(name),i,0)
self.network_layout.addWidget(hidden_layers[i],i,1)
self.hidden_layers = hidden_layers
def rendering_changed(self):
if self.rendering_enabled.isChecked() == True:
self.render_frequency = QLineEdit('200')
self.render_frequency_label = QLabel('Rendering frequency:')
self.rendering_layout.addWidget(self.render_frequency_label, 0,0)
self.rendering_layout.addWidget(self.render_frequency, 0,1)
else:
self.render_frequency.hide()
self.render_frequency_label.hide()
self.rendering_layout.removeWidget(self.rendering_layout.itemAt(0).widget())
self.rendering_layout.removeWidget(self.rendering_layout.itemAt(0).widget())
del self.render_frequency
del self.render_frequency_label
def load_weights_changed(self):
if self.load_weights_enabled.isChecked() == True:
self.load_weights_filename = QLineEdit()
self.load_weights_filename_label = QLabel('Storage file:')
self.load_layout.addWidget(self.load_weights_filename_label, 0, 0)
self.load_layout.addWidget(self.load_weights_filename, 0, 1)
else:
self.load_weights_filename.hide()
self.load_weights_filename_label.hide()
self.load_layout.removeWidget(self.load_layout.itemAt(0).widget())
self.load_layout.removeWidget(self.load_layout.itemAt(0).widget())
del self.load_weights_filename
del self.load_weights_filename_label
def save_weights_changed(self, value):
if self.save_weights_enabled.isChecked() == True:
self.save_weights_filename = QLineEdit()
self.save_weights_filename_label = QLabel('Storage file:')
self.weight_saving_frequency = QLineEdit('100')
self.weight_saving_frequency_label = QLabel('Weight saving frequency:')
self.save_layout.addWidget(self.save_weights_filename_label,0,0)
self.save_layout.addWidget(self.save_weights_filename,0,1)
self.save_layout.addWidget(self.weight_saving_frequency_label,1,0)
self.save_layout.addWidget(self.weight_saving_frequency,1,1)
else:
self.save_weights_filename.hide()
self.save_weights_filename_label.hide()
self.weight_saving_frequency.hide()
self.weight_saving_frequency_label.hide()
self.save_layout.removeWidget(self.save_layout.itemAt(0).widget())
self.save_layout.removeWidget(self.save_layout.itemAt(0).widget())
self.save_layout.removeWidget(self.save_layout.itemAt(0).widget())
self.save_layout.removeWidget(self.save_layout.itemAt(0).widget())
del self.save_weights_filename
del self.save_weights_filename_label
del self.weight_saving_frequency
del self.weight_saving_frequency_label
def variable_updating_changed(self):
if self.variable_updating_enabled.isChecked() == True:
self.update_target_frequency_base = QLineEdit('50')
self.update_target_frequency_base_label = QLabel('Update target frequency base:')
self.update_target_frequency_multiplicator = QLineEdit('1.1')
self.update_target_frequency_multiplicator_label = QLabel('Update target frequency multiplicator:')
self.update_target_frequency_limit = QLineEdit('800')
self.update_target_frequency_limit_label = QLabel('Update target frequency limit:')
self.variable_updating_layout.addWidget(self.update_target_frequency_base_label,0,0)
self.variable_updating_layout.addWidget(self.update_target_frequency_base,0,1)
self.variable_updating_layout.addWidget(self.update_target_frequency_multiplicator_label,1,0)
self.variable_updating_layout.addWidget(self.update_target_frequency_multiplicator,1,1)
self.variable_updating_layout.addWidget(self.update_target_frequency_limit_label,2,0)
self.variable_updating_layout.addWidget(self.update_target_frequency_limit,2,1)
else:
self.update_target_frequency_base.hide()
self.update_target_frequency_base_label.hide()
self.update_target_frequency_multiplicator.hide()
self.update_target_frequency_multiplicator_label.hide()
self.update_target_frequency_limit.hide()
self.update_target_frequency_limit_label.hide()
self.variable_updating_layout.removeWidget(self.variable_updating_layout.itemAt(0).widget())
self.variable_updating_layout.removeWidget(self.variable_updating_layout.itemAt(0).widget())
self.variable_updating_layout.removeWidget(self.variable_updating_layout.itemAt(0).widget())
self.variable_updating_layout.removeWidget(self.variable_updating_layout.itemAt(0).widget())
self.variable_updating_layout.removeWidget(self.variable_updating_layout.itemAt(0).widget())
self.variable_updating_layout.removeWidget(self.variable_updating_layout.itemAt(0).widget())
del self.update_target_frequency_base
del self.update_target_frequency_base_label
del self.update_target_frequency_multiplicator
del self.update_target_frequency_multiplicator_label
del self.update_target_frequency_limit
del self.update_target_frequency_limit_label
def create_charts(self):
self.actual_score_chart = pg.plot()
self.actual_score_chart.setTitle('Actual score')
self.actual_score_chart.setLabel('left', 'score')
self.actual_score_chart.setLabel('bottom', 'episode')
self.actual_score_x = []
self.actual_score_y = []
self.actual_score_bar = pg.BarGraphItem(x=self.actual_score_x, height=self.actual_score_y, width=1, brush='b')
self.actual_score_chart.addItem(self.actual_score_bar)
self.steps_chart = pg.plot()
self.steps_chart.setTitle('Steps per episode')
self.steps_chart.setLabel('left', 'steps')
self.steps_chart.setLabel('bottom', 'episode')
self.steps_x = []
self.steps_y = []
self.steps_bar = pg.BarGraphItem(x=self.steps_x, height=self.steps_y, width=1, brush='b')
self.steps_chart.addItem(self.steps_bar)
self.score_avg = pg.PlotWidget()
self.score_avg.setTitle('Average score')
self.score_avg.setLabel('left', 'score')
self.score_avg.setLabel('bottom', 'episode')
self.score_avg_x = []
self.score_avg_y = []
self.score_avg_line = self.score_avg.plot(self.score_avg_x, self.score_avg_y)
self.score_avg_100 = pg.PlotWidget()
self.score_avg_100.setTitle('Average score last 100 episodes')
self.score_avg_100.setLabel('left', 'score')
self.score_avg_100.setLabel('bottom', 'episode')
self.score_avg_100_x = []
self.score_avg_100_y = []
self.score_avg_100_line =self.score_avg_100.plot(self.score_avg_100_x, self.score_avg_100_y)
self.score_avg_report = pg.PlotWidget()
self.score_avg_report.setTitle('Average score last report interval episodes')
self.score_avg_report.setLabel('left', 'score')
self.score_avg_report.setLabel('bottom', 'episode')
self.score_avg_report_x = []
self.score_avg_report_y = []
self.score_avg_report_line =self.score_avg_report.plot(self.score_avg_report_x, self.score_avg_report_y)
self.egreedy_chart = pg.PlotWidget()
self.egreedy_chart.setTitle('E-greedy')
self.egreedy_chart.setLabel('left', 'egreedy')
self.egreedy_chart.setLabel('bottom', 'episode')
self.egreedy_chart_x = []
self.egreedy_chart_y = []
self.egreedy_chart_line =self.egreedy_chart.plot(self.egreedy_chart_x, self.egreedy_chart_y)
def reset_charts(self):
self.egreedy_chart_x = []
self.egreedy_chart_y = []
self.egreedy_chart_line.setData(self.egreedy_chart_x, self.egreedy_chart_y)
self.steps_x = []
self.steps_y = []
self.steps_bar.setOpts(x= self.steps_x, height = self.steps_y)
self.score_avg_x = []
self.score_avg_y = []
self.score_avg_line.setData(self.score_avg_x, self.score_avg_y)
self.score_avg_100_x = []
self.score_avg_100_y = []
self.score_avg_100_line.setData(self.score_avg_100_x, self.score_avg_100_y)
self.score_avg_report_x = []
self.score_avg_report_y = []
self.score_avg_report_line.setData(self.score_avg_report_x, self.score_avg_report_y)
self.actual_score_x = []
self.actual_score_y = []
self.score_avg_report_line.setData(self.score_avg_report_x, self.score_avg_report_y)
def update_egreedy(self, data):
if len(self.egreedy_chart_x) == 0:
self.egreedy_chart_x.append(0)
self.egreedy_chart_y.append(data)
elif len(self.egreedy_chart_x) < 50:
self.egreedy_chart_x.append(self.egreedy_chart_x[-1] + 1)
self.egreedy_chart_y.append(data)
else:
self.egreedy_chart_x = self.egreedy_chart_x[1:]
self.egreedy_chart_y = self.egreedy_chart_y[1:]
self.egreedy_chart_x.append(self.egreedy_chart_x[-1] + 1)
self.egreedy_chart_y.append(data)
self.egreedy_chart_line.setData(self.egreedy_chart_x, self.egreedy_chart_y)
def update_steps(self,data):
if len(self.steps_x) == 0:
self.steps_x.append(0)
self.steps_y.append(data)
elif len(self.steps_x) < 50:
self.steps_x.append(self.steps_x[-1] + 1)
self.steps_y.append(data)
else:
self.steps_x = self.steps_x[1:]
self.steps_y = self.steps_y[1:]
self.steps_x.append(self.steps_x[-1] + 1)
self.steps_y.append(data)
self.steps_bar.setOpts(x= self.steps_x, height = self.steps_y)
def update_score_avg(self, data):
if len(self.score_avg_x) == 0:
self.score_avg_x.append(0)
self.score_avg_y.append(data)
elif len(self.score_avg_x) < 50:
self.score_avg_x.append(self.score_avg_x[-1] + 1)
self.score_avg_y.append(data)
else:
self.score_avg_x = self.score_avg_x[1:]
self.score_avg_y = self.score_avg_y[1:]
self.score_avg_x.append(self.score_avg_x[-1] + 1)
self.score_avg_y.append(data)
self.score_avg_line.setData(self.score_avg_x, self.score_avg_y)
def update_score_avg_100(self,data):
if len(self.score_avg_100_x) == 0:
self.score_avg_100_x.append(0)
self.score_avg_100_y.append(data)
elif len(self.score_avg_100_x) < 50:
self.score_avg_100_x.append(self.score_avg_100_x[-1] + 1)
self.score_avg_100_y.append(data)
else:
self.score_avg_100_x = self.score_avg_100_x[1:]
self.score_avg_100_y = self.score_avg_100_y[1:]
self.score_avg_100_x.append(self.score_avg_100_x[-1] + 1)
self.score_avg_100_y.append(data)
self.score_avg_100_line.setData(self.score_avg_100_x, self.score_avg_100_y)
def update_score_avg_report(self, data):
if len(self.score_avg_report_x) == 0:
self.score_avg_report_x.append(0)
self.score_avg_report_y.append(data)
elif len(self.score_avg_report_x) < 50:
self.score_avg_report_x.append(self.score_avg_report_x[-1] + 1)
self.score_avg_report_y.append(data)
else:
self.score_avg_report_x = self.score_avg_report_x[1:]
self.score_avg_report_y = self.score_avg_report_y[1:]
self.score_avg_report_x.append(self.score_avg_report_x[-1] + 1)
self.score_avg_report_y.append(data)
self.score_avg_report_line.setData(self.score_avg_report_x, self.score_avg_report_y)
def update_actual_score(self, data):
if len(self.actual_score_x) == 0:
self.actual_score_x.append(0)
self.actual_score_y.append(data)
elif len(self.actual_score_x) < 50:
self.actual_score_x.append(self.actual_score_x[-1] + 1)
self.actual_score_y.append(data)
else:
self.actual_score_x = self.actual_score_x[1:]
self.actual_score_y = self.actual_score_y[1:]
self.actual_score_x.append(self.actual_score_x[-1] + 1)
self.actual_score_y.append(data)
self.actual_score_bar.setOpts(x=self.actual_score_x, height=self.actual_score_y)
def callback(self,data):
parsed = data.split(',')
if len(parsed) != 10:
print('trash ' + data)
self.update_egreedy(float(parsed[0]))
self.update_actual_score(float(parsed[1]))
self.update_score_avg(float(parsed[2]))
self.update_score_avg_100(float(parsed[3]))
self.update_score_avg_report(float(parsed[4]))
self.update_steps(int(parsed[5]))
self.update_progress_bar_layout(parsed[6],parsed[7],parsed[8],parsed[9],parsed[3])
def create_displayer(self):
self.display_controls = QGroupBox('Controls')
self.display_controls_layout = QVBoxLayout()
self.display_controls_layout.setAlignment(Qt.AlignTop)
self.file_picker_button = QPushButton('Select file')
self.file_picker_button.clicked.connect(self.on_file_pick)
self.display_controls_layout.addWidget(self.file_picker_button,1)
widget = QWidget()
scroll = QScrollArea()
scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
scroll.setWidgetResizable(True)
scroll.setWidget(widget)
widget.setLayout(self.display_controls_layout)
group_layout = QVBoxLayout()
group_layout.addWidget(scroll)
self.display_controls.setLayout(group_layout)
self.display_graph_group = QGroupBox('Chart')
self.display_graph_layout = QVBoxLayout()
self.display_graph_group.setLayout(self.display_graph_layout)
self.create_displayer_graph_layout()
self.display_layout = QHBoxLayout()
self.display_layout.addWidget(self.display_controls, 1)
self.display_layout.addWidget(self.display_graph_group,4)
self.results_tab.setLayout(self.display_layout)
self.displayer_data = []
def on_file_pick(self):
filename = QFileDialog.getOpenFileName(directory=str(os.path.abspath(os.getcwd())))
with open(filename[0], 'r') as f:
self.displayer_data.append(json.load(f))
self.after_file_pick(filename[0])
def after_file_pick(self, filename):
layout = QGridLayout()
index_database = len(self.displayer_data) - 1
index = 0
for field in self.displayer_data[-1]:
label = QLabel(field + ': ')
if type(self.displayer_data[-1][field]) == list:
data = QPushButton('Display in chart')
data.clicked.connect(lambda x, y = field: self.on_display_in_chart(index_database, y))
layout.addWidget(label, index, 0)
layout.addWidget(data, index, 1)
else:
data = QLabel(str(self.displayer_data[-1][field]))
layout.addWidget(label, index, 0)
layout.addWidget(data, index, 1)
index += 1
close = QPushButton('Close file')
close.clicked.connect(lambda: self.on_close(index_database))
mean = QPushButton('create mean row')
mean.clicked.connect(lambda: self.on_create_modal(index_database))
layout.addWidget(close,100,0)
layout.addWidget(mean,100,1)
group = QGroupBox(str(index_database))
group.setLayout(layout)
group.setFixedHeight(30* index + 1)
self.display_controls_layout.addWidget(group,0)
def on_display_in_chart(self,index,field):
colors= ['r','g','b','y','w']
data = self.displayer_data[index][field]
if(self.color_index == len(colors)):
return
self.displayer_chart_y = data
if self.chart_type == 'LINE':
indexes = [i for i in range(len(data))]
self.displayer_chart_x = indexes
self.displayer_chart.clearMouse()
self.displayer_chart_data = self.displayer_chart.plot(self.displayer_chart_x, self.displayer_chart_y, name=field, pen=pg.mkPen(colors[self.color_index], width=1))
else:
indexes = [i + self.color_index * 0.1 for i in range(len(data))]
self.displayer_chart_x = indexes
data = pg.BarGraphItem(x=self.displayer_chart_x, height=self.displayer_chart_y, name=field , width=0.2, brush=colors[self.color_index])
self.displayer_chart.addItem(data)
self.color_index += 1
# def plot(self, x, y, plotname, color):
# pen = pg.mkPen(color=color)
# self.graphWidget.plot(x, y, name=plotname, pen=pen, symbol='+', symbolSize=30, symbolBrush=(color))
def on_create_modal(self, data_index):
self.dialog = QDialog(self)
layout = QGridLayout()
subset_label = QLabel('subset length: ')
subset = QLineEdit('-1')
hint = QLabel('-1 stands for all data if continous enabled mean will be computed for every x entries if static is selected mean will be computed from last x entries')
continuous = QCheckBox('Continuous')
continuous.setChecked(True)
layout.addWidget(continuous,0,0)
layout.addWidget(subset_label,1,0)
layout.addWidget(subset,1,1)
layout.addWidget(hint,2,0,0,-1)
name_label = QLabel('row name: ')
name = QLineEdit()
layout.addWidget(name_label,3,0)
layout.addWidget(name,3,1)
index = 4
for field in self.displayer_data[-1]:
if type(self.displayer_data[-1][field]) == list:
label = QLabel(field + ': ')
data = QPushButton('Select this row')
data.clicked.connect(lambda x, y=field:self.create_mean_row(continuous.isChecked(),data_index,int(subset.text()),name.text(),y))
layout.addWidget(label, index, 0)
layout.addWidget(data, index, 1)
index += 1
self.dialog.setLayout(layout)
self.dialog.exec()
def create_mean_row(self,contunous,data_index,subset,row_name,origin_row_name):
index = len(self.displayer_data[data_index])
if contunous:
data = []
if subset != -1:
for i in range(1,len(self.displayer_data[data_index][origin_row_name])):
if i <= subset:
data.append(self.mean(self.displayer_data[data_index][origin_row_name][0:i]))
else:
data.append(self.mean(self.displayer_data[data_index][origin_row_name][i-subset:i]))
else:
for i in range(1,len(self.displayer_data[data_index][origin_row_name])):
data.append(self.mean(self.displayer_data[data_index][origin_row_name][:i]))
self.displayer_data[data_index][row_name] = data
label = QLabel(row_name+': ')
btn= QPushButton('Display in chart')
btn.clicked.connect(lambda x, y = row_name: self.on_display_in_chart(data_index, y))
self.display_controls_layout.itemAt(data_index+1).widget().layout().addWidget(label,index,0)
self.display_controls_layout.itemAt(data_index+1).widget().layout().addWidget(btn,index,1)
else:
if subset == -1:
mean = self.mean(self.displayer_data[data_index][origin_row_name])
else:
mean = self.mean(self.displayer_data[data_index][origin_row_name][-subset:])
label = QLabel(row_name+': ')
data = QLabel('{0:.2f}'.format(mean))
self.display_controls_layout.itemAt(data_index + 1).widget().layout().addWidget(label, index, 0)
self.display_controls_layout.itemAt(data_index + 1).widget().layout().addWidget(data, index, 1)
self.display_controls_layout.itemAt(data_index + 1).widget().setFixedHeight((self.display_controls_layout.itemAt(data_index + 1).widget().layout().count()/2) * 30)
self.dialog.close()
def mean(self,data):
return sum(data)/len(data)
def on_close(self,index):
widget = self.display_controls_layout.itemAt(index + 1)
widget.widget().hide()
self.display_controls_layout.removeWidget(widget.widget())
self.displayer_data.pop(index)
def create_displayer_graph_layout(self):
self.displayer_chart_top_layout = QVBoxLayout()
chart_widget = QWidget()
chart_widget.setLayout(self.displayer_chart_top_layout)
self.display_graph_layout.addWidget(chart_widget,5)
self.create_chart_displayer(False)
self.bar = QRadioButton('bar char')
self.bar.setChecked(False)
self.bar.clicked.connect(lambda: self.create_chart_displayer(True))
self.line = QRadioButton('line chart')
self.line.setChecked(True)
self.line.clicked.connect(lambda :self.create_chart_displayer(False))
chart_title_label = QLabel('Chart title:')
self.chart_title = QLineEdit()
self.chart_title.textChanged.connect(lambda : self.displayer_chart.setTitle(self.chart_title.text()))
x_axis_title_label = QLabel('X axis title:')
x_axis_title = QLineEdit()
x_axis_title.textChanged.connect(lambda : self.displayer_chart.setLabel('bottom',x_axis_title.text()))
y_axis_title_label = QLabel('Y axis title:')
y_axis_title = QLineEdit()
y_axis_title.textChanged.connect(lambda : self.displayer_chart.setLabel('left',y_axis_title.text()))
clear_plot = QPushButton('Clear plot')
clear_plot.clicked.connect(lambda: self.create_chart_displayer(self.chart_type == 'BAR'))
export_plot = QPushButton('Export plot')
export_plot.clicked.connect(lambda: self.export_plot())
layout = QGridLayout()
layout.addWidget(self.bar,0,0,1,1)
layout.addWidget(self.line,0,1,1,-1)
layout.addWidget(chart_title_label,1,0,1,1)
layout.addWidget(self.chart_title,1,1,1,1)
layout.addWidget(x_axis_title_label,1,2,1,1)
layout.addWidget(x_axis_title,1,3,1,1)
layout.addWidget(y_axis_title_label,1,4,1,1)
layout.addWidget(y_axis_title,1,5,1,1)
layout.addWidget(clear_plot, 2,1)
layout.addWidget(export_plot, 2,3)
chart_control_widget = QWidget()
chart_control_widget.setLayout(layout)
self.display_graph_layout.addWidget(chart_control_widget,2)
def export_plot(self):
exporter = pg.exporters.ImageExporter(self.displayer_chart.plotItem)
exporter.params.param('width').setValue(960, blockSignal=exporter.widthChanged)
exporter.params.param('height').setValue(400, blockSignal=exporter.heightChanged)
exporter.export('export.png')
def create_chart_displayer(self,bar):
self.displayer_chart = pg.PlotWidget()
self.color_index = 0
if bar:
self.displayer_chart_x = []
self.displayer_chart_y = []
self.displayer_chart_data = pg.BarGraphItem(x=self.displayer_chart_x, height=self.displayer_chart_y, width=1, brush='b')
self.displayer_chart.addItem(self.displayer_chart_data)
self.chart_type = 'BAR'
else:
self.displayer_chart.addLegend()
self.displayer_chart_x = []
self.displayer_chart_y = []
self.displayer_chart_data = self.displayer_chart.plot(self.displayer_chart_x, self.displayer_chart_y)
self.chart_type = 'LINE'
for i in range(self.displayer_chart_top_layout.count()):
tmp = self.displayer_chart_top_layout.itemAt(0).widget()
tmp.hide()
self.displayer_chart_top_layout.removeWidget(tmp)
self.displayer_chart_top_layout.addWidget(self.displayer_chart)
class GameWithCards(QDialog, Ui_Dialog):
def __init__(self, parent):
super().__init__()
self.setupUi(self)
self.setWindowTitle("Заучивание набора карточек")
"""Подключение базы данных"""
self.con = sqlite3.connect("quiz.db")
self.cur = self.con.cursor()
"""Остальное"""
self.par = parent # родитель этого класса
self.rejected.connect(self.open_choice) # если он нажмет cancle
self.accepted.connect(self.open_choice) # если он нажмет yes
self.widget = QWidget()
self.set_label.setText(f"Заучиваем набор: {self.par.set_name}")
self.game = True
self.not_right_style = "color: rgb(125, 0, 0);font: 15pt 'Helvetica';"
self.right_style = "color: rgb(0, 125, 0);font: 15pt 'Helvetica';"
self.right_cards = []
self.button_group = QButtonGroup()
self.button_group.addButton(self.check_button)
self.button_group.buttonClicked.connect(self.what_to_do)
if self.game:
self.start_game()
def what_to_do(self, button):
"""Смотрит по названию кнопки, что она должна выполнить"""
self.button_name = button.text()
if self.button_name == "Проверить":
self.check_button.setText('Продолжить')
self.word.setDisabled(True)
self.check_answer()
elif self.button_name == "Продолжить":
if not self.cards:
self.end_of_game()
else:
self.check_button.setText('Проверить')
self.next_card()
def next_card(self):
"""Заменяет карточку на следующую"""
self.right_or_not.setText(" ")
self.num += 1
self.word.setDisabled(False)
try:
self.hor.itemAt(0).widget().setParent(None)
self.hor.addWidget(self.cards[self.num])
except IndexError:
self.num = 0
rd.shuffle(self.cards)
self.hor.addWidget(self.cards[self.num])
def check_answer(self):
"""Проверяет правильность значения, меняет тескст в нижнем лэйбле"""
self.right_answer = self.cards[self.num].mean
copy_right = self.right_answer.lower()
self.right_word = self.cards[self.num].word
self.answer = self.word.text()
copy_answer = self.answer.lower()
self.answer = self.answer.strip()
if copy_right == copy_answer:
self.right_or_not.setText(
f"Вы ответили верно, {self.right_word} - {self.right_answer}")
self.right_or_not.setStyleSheet(self.right_style)
self.cards.pop(self.num)
else:
self.right_or_not.setText(
f"Вы ответили неверно, правильный ответ - {self.right_answer}")
self.right_or_not.setStyleSheet(self.not_right_style)
def get_all_cards(self):
"""Возвращает массив, заполненный полность карточками из выбранного сета"""
id_of_set = self.cur.execute(
"""SELECT id FROM Sets WHERE login = ? and title = ?""",
(self.par.login, self.par.set_name)).fetchone()[0]
cards = self.cur.execute("""SELECT * FROM Card WHERE sets LIKE ?""",
(f'%{id_of_set};%', )).fetchall()
if not cards:
return "-1"
list_of_cards = []
for card in cards:
id = card[0]
image = card[1]
trans = card[2]
word = card[3]
list_of_cards.append(Card(word, trans, image, id, False))
rd.shuffle(list_of_cards)
return list_of_cards
def start_game(self):
"""Тут начинается вся игра"""
self.num = 0
self.cards = self.get_all_cards() # Создается массив
self.lenght = len(self.cards)
self.hor.addWidget(self.cards[self.num])
self.before_the_game()
def open_choice(self):
"""Если он захочет закончить игру"""
"""открывает выбор, хочет ли пользователь войти без регистрации"""
reply = QMessageBox.question(self, '',
"Вы точно хотите прервать игру?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.Yes:
self.hide()
self.game = False
self.par.show()
else:
self.show()
def before_the_game(self):
"""До начала игры тут показываются правила"""
reply = QMessageBox.question(
self, 'Правила',
f"Перед началом игры хотелось бы рассказать немного о том, что тут вообще "
f"надо делать. Тут все сделано в игровой форме и не на время, так что можете не торопиться, "
f"в специальном поле будет появляться карточка с текстом без перевода, его вам и надо "
f"будет ввести в поле, далее нажимайте единственную кнопку, и все, приятной игры) ",
QMessageBox.Yes)
if reply == QMessageBox.Yes:
pass
def end_of_game(self):
"""Когда ты выучил все слова"""
reply = QMessageBox.question(
self, 'Конец, вы молодец!',
f"Вы уже заучили этот набор, вы выучили сейчас карточек: {self.lenght}",
QMessageBox.Yes)
if reply == QMessageBox.Yes:
self.par.show()
self.hide()
def _show_aboutbox(self, title, logo, homepage_url, versions, license_text,
links):
"""
Shows an about dialog box with the specified parameters.
Params:
title (str) Application title
logo (str) Absolute path to application's logo
homepage_url (str) HTTPS link to the project's homepage
versions (list) Table of strings: [["name": "ver"]]
license_text (str) Show this license text.
links (list) List of links: [["label": "url"]]
"""
about = shared.get_ui_widget(self.appdata, "about", QDialog)
_ = self.appdata._
# Logo
about_icon = about.findChild(QLabel, "AppIcon")
shared.set_pixmap_for_label(about_icon, logo, 96)
# App Name
name = about.findChild(QLabel, "AppName")
name.setText(title)
# URL under the application title
url = about.findChild(QLabel, "AppURL")
def _link(a):
webbrowser.open(homepage_url)
url.mousePressEvent = _link
url.setText(homepage_url)
# Set text colour if using Polychromatic Qt theme
if not self.appdata.system_qt_theme:
name.setStyleSheet("QLabel { color: lime }")
url.setStyleSheet("QLabel { color: lime }")
# List versions & dependencies
tree = about.findChild(QTreeWidget, "VersionTree")
column = tree.invisibleRootItem()
for version in versions:
item = QTreeWidgetItem()
item.setText(0, version[0])
item.setText(1, version[1])
column.addChild(item)
# Add application links
links_widget = about.findChild(QWidget, "TabLinks").layout()
button_grp = QButtonGroup()
for button in links:
label = button[0]
href = button[1]
btn = QPushButton(QIcon(common.get_icon("general", "external")),
label)
btn.setToolTip(href)
btn.href = href
button_grp.addButton(btn)
links_widget.addWidget(btn)
def clicked_button_grp(button):
webbrowser.open(button.href)
button_grp.buttonClicked.connect(clicked_button_grp)
# Show license text
license = about.findChild(QTextEdit, "LicenseText")
license.setPlainText(license_text)
# Set up the about window
close = about.findChild(QPushButton, "Close")
def _close(a):
about.accept()
close.clicked.connect(_close)
if not self.appdata.system_qt_theme:
close.setIcon(self.widgets.get_icon_qt("general", "close"))
window_title = ' '.join(sub[:1].upper() + sub[1:]
for sub in title.split(' '))
about.setWindowTitle(_("About []").replace("[]", window_title))
about.setWindowIcon(QIcon(logo))
about.setWindowFlag(Qt.WindowMinimizeButtonHint, False)
about.setWindowFlag(Qt.WindowMaximizeButtonHint, False)
about.exec()
class Application(QMainWindow):
def __init__(self, im_hs, height):
super().__init__()
self.setWindowTitle("Segmentation UI")
self.imflag = "Image"
self.getim(im_hs)
self.getparams()
self.prev_params = parameters()
self.prev_params.generate()
offset = 50
self.canvas_size = height
self.layout = QHBoxLayout(self)
# Initialize tab screen
self.tabs = QTabWidget()
self.tab1 = QWidget()
self.tab2 = QWidget()
self.tab3 = QWidget()
# Add tabs
self.tabs.addTab(self.tab1, "Auto")
self.tabs.addTab(self.tab2, "Manual")
self.tabs.addTab(self.tab3, "Trainable")
#self.central_widget = QWidget()
#self.setCentralWidget(self.central_widget)
lay = QHBoxLayout()
leftlay = QVBoxLayout()
rightlay = QVBoxLayout()
self.tab1.setLayout(lay)
#tab 1
self.label = QLabel(self)
qi = QImage(self.image.data, self.image.shape[1], self.image.shape[0],
self.image.shape[1], QImage.Format_Grayscale8)
pixmap = QPixmap(qi)
self.pixmap2 = pixmap.scaled(self.canvas_size, self.canvas_size,
Qt.KeepAspectRatio)
self.label.setPixmap(self.pixmap2)
self.label.setGeometry(10, 10, self.pixmap2.width(),
self.pixmap2.height())
height = max((self.pixmap2.height() + 50, 300 + offset)) #300 +50
self.resize(self.pixmap2.width() + 130, height)
self.filt_title = QLabel(self)
self.filt_title.setText('Pre-filtering options')
self.sptxt = QLabel(self)
self.sptxt.setText('Rolling ball size')
self.sp = QSpinBox(self)
self.sp.setMaximum(self.image.shape[0])
self.sp.valueChanged.connect(self.rollingball)
self.gausstxt = QLabel(self)
self.gausstxt.setText('Gaussian filter kernel size')
self.gauss = QSpinBox(self)
self.gauss.setMaximum(self.image.shape[0])
self.gauss.valueChanged.connect(self.gaussian)
self.thresh_title = QLabel(self)
self.thresh_title.setText('Thresholding options')
self.comboBox = QComboBox(self)
self.comboBox.addItem("Otsu")
self.comboBox.addItem("Mean")
self.comboBox.addItem("Minimum")
self.comboBox.addItem("Yen")
self.comboBox.addItem("Isodata")
self.comboBox.addItem("Li")
self.comboBox.addItem("Local")
self.comboBox.addItem("Local Otsu")
self.comboBox.addItem("Local+Global Otsu")
self.comboBox.addItem("Niblack")
self.comboBox.addItem("Sauvola")
self.comboBox.activated[str].connect(self.threshold_choice)
self.comboBox.activated.connect(self.updateLocalSize)
self.localtxt = QLabel(self)
self.localtxt.setText('Local filter kernel')
self.local_size = QSpinBox(self)
self.local_size.valueChanged.connect(self.local)
self.local_size.setEnabled(False)
cb = QCheckBox('Watershed', self)
cb.stateChanged.connect(self.changeWatershed)
self.ws_title = QLabel(self)
self.ws_title.setText('Watershed Seed Separation')
self.watershed_size = QSpinBox(self)
self.watershed_size.setMaximum(self.image.shape[0])
self.watershed_size.valueChanged.connect(self.watershed)
self.watershed_size.setEnabled(False)
self.wse_title = QLabel(self)
self.wse_title.setText('Watershed Seed Erosion')
self.watershed_erosion = QSpinBox(self)
self.watershed_erosion.setMaximum(self.image.shape[0])
self.watershed_erosion.valueChanged.connect(self.watershed_e)
self.watershed_erosion.setEnabled(False)
cb2 = QCheckBox('Invert', self)
cb2.stateChanged.connect(self.changeInvert)
self.minsizetxt = QLabel(self)
self.minsizetxt.setText('Min particle size (px)')
self.minsizev = QSpinBox(self)
self.minsizev.setMaximum(self.image.shape[0] * self.image.shape[1])
self.minsizev.valueChanged.connect(self.minsize)
updateb = QPushButton('Update', self)
updateb.clicked.connect(self.update)
paramsb = QPushButton('Get Params', self)
paramsb.clicked.connect(self.return_params)
self.imagetxt = QLabel(self)
self.imagetxt.setText('Display:')
self.imBox = QComboBox(self)
self.imBox.addItem("Image")
self.imBox.addItem("Labels")
self.imBox.activated[str].connect(self.changeIm)
leftlay.addWidget(self.label)
leftlay.addWidget(self.imagetxt)
leftlay.addWidget(self.imBox)
rightlay.addWidget(self.filt_title)
rightlay.addWidget(self.sptxt)
rightlay.addWidget(self.sp)
rightlay.addWidget(self.gausstxt)
rightlay.addWidget(self.gauss)
rightlay.addStretch(1)
rightlay.addWidget(self.thresh_title)
rightlay.addWidget(self.comboBox)
rightlay.addStretch(1)
rightlay.addWidget(self.localtxt)
rightlay.addWidget(self.local_size)
rightlay.addStretch(1)
rightlay.addWidget(cb)
rightlay.addWidget(self.ws_title)
rightlay.addWidget(self.watershed_size)
rightlay.addWidget(self.wse_title)
rightlay.addWidget(self.watershed_erosion)
rightlay.addStretch(1)
rightlay.addWidget(cb2)
rightlay.addStretch(1)
rightlay.addWidget(self.minsizetxt)
rightlay.addWidget(self.minsizev)
rightlay.addStretch(1)
rightlay.addWidget(updateb)
rightlay.addWidget(paramsb)
lay.addLayout(leftlay)
lay.addLayout(rightlay)
self.layout.addWidget(self.tabs)
self.setLayout(self.layout)
self.setCentralWidget(self.tabs)
#Tab 2
self.canvas = Canvas(self.pixmap2, self.canvas_size)
#self.canvas = Drawer(self.pixmap2)
self.getarrayb = QPushButton('Save Segmentation', self)
self.getarrayb.clicked.connect(self.save_array)
tab2layout = QVBoxLayout()
tab2layout.addWidget(self.canvas)
tab2layout.addWidget(self.getarrayb)
tab2layout.addStretch(1)
self.tab2.setLayout(tab2layout)
#Tab 3
self.mask = np.zeros([self.canvas_size, self.canvas_size, 3])
self.classifier = GaussianNB()
self.tsparams = trainable_parameters()
self.filter_kernels = [
'Gaussian', 'Diff. Gaussians', 'Median', 'Minimum', 'Maximum',
'Sobel', 'Hessian', 'Laplacian', 'M-Sum', 'M-Mean',
'M-Standard Deviation', 'M-Median', 'M-Minimum', 'M-Maximum'
]
lay3 = QHBoxLayout()
im_lay = QVBoxLayout()
self.button_lay = QVBoxLayout()
self.button_lay.setSpacing(0)
self.button_lay.setContentsMargins(0, 0, 0, 0)
lay3.addLayout(self.button_lay)
lay3.addLayout(im_lay)
self.canvas2 = Canvas(self.pixmap2, self.canvas_size)
self.canvas2.setAlignment(Qt.AlignTop)
self.tool_lay = QVBoxLayout()
self.tool_group = QButtonGroup()
for tool in self.canvas2.brush_tools:
b = ToolButton(tool)
b.pressed.connect(lambda tool=tool: self.canvas2.changePen(tool))
b.setText(tool)
self.tool_group.addButton(b)
if tool == 'Freehand':
b.setChecked(True)
self.tool_lay.addWidget(b)
self.button_lay.addItem(self.tool_lay)
self.colour_lay = QHBoxLayout()
for i in range(len(self.canvas2.colors)):
c = self.canvas2.colors[i]
b = QPaletteButton(c)
b.pressed.connect(lambda i=i: self.canvas2.set_pen_color(i))
if i == 0:
b.setChecked(True)
self.colour_lay.addWidget(b)
self.button_lay.addLayout(self.colour_lay)
im_lay.addWidget(self.canvas2)
self.kerneltxt = QLabel(self)
self.kerneltxt.setText('Classifier')
self.button_lay.addWidget(self.kerneltxt)
self.clfBox = QComboBox(self)
self.clfBox.addItem("Random Forest")
self.clfBox.addItem("Nearest Neighbours")
self.clfBox.addItem("Naive Bayes")
self.clfBox.addItem("QDA")
self.clfBox.activated[str].connect(self.classifier_choice)
self.button_lay.addWidget(self.clfBox)
fk_lay = QVBoxLayout(self)
self.kerneltxt = QLabel(self)
self.kerneltxt.setText('Filter Kernels')
fk_lay.addWidget(self.kerneltxt)
for t in range(8):
b = QCheckBox(self.filter_kernels[t], self)
b.pressed.connect(
lambda tool=self.filter_kernels[t]: self.toggle_fk(tool))
if t in (0, 1, 2, 3, 4, 5, 8):
b.setChecked(True)
fk_lay.addWidget(b)
self.membranetext = QLabel(self)
self.membranetext.setText('Membrane Projections')
fk_lay.addWidget(self.membranetext)
for t in range(8, 14):
b = QCheckBox(self.filter_kernels[t][2:], self)
b.pressed.connect(
lambda tool=self.filter_kernels[t]: self.toggle_fk(tool))
if t in (0, 1, 2, 3, 4, 5, 8):
b.setChecked(True)
fk_lay.addWidget(b)
self.button_lay.addLayout(fk_lay)
fkp_lay = QVBoxLayout()
self.ql1 = QLabel(self)
self.ql1.setText('Sigma')
fkp_lay.addWidget(self.ql1)
self.spinb1 = QSpinBox(self)
self.spinb1.valueChanged.connect(self.change_sigma)
self.spinb1.setValue(1)
fkp_lay.addWidget(self.spinb1)
self.ql2 = QLabel(self)
self.ql2.setText('High Sigma')
fkp_lay.addWidget(self.ql2)
self.spinb2 = QSpinBox(self)
self.spinb2.valueChanged.connect(self.change_high_sigma)
self.spinb2.setValue(16)
fkp_lay.addWidget(self.spinb2)
self.ql3 = QLabel(self)
self.ql3.setText('Disk Size')
fkp_lay.addWidget(self.ql3)
self.spinb3 = QSpinBox(self)
self.spinb3.valueChanged.connect(self.change_disk)
self.spinb3.setValue(20)
fkp_lay.addWidget(self.spinb3)
self.button_lay.addLayout(fkp_lay)
"""
self.config = QPushButton('Configure Filter Kernels', self)
#self.config.clicked.connect()
self.config.setToolTip('Choose individual filter kernel parameters')
self.button_lay.addWidget(self.config)
"""
self.clear = QPushButton('Clear Training Labels', self)
self.clear.setToolTip('Removes existing training labels memory')
self.clear.clicked.connect(self.canvas2.clearLabels)
self.button_lay.addWidget(self.clear)
self.redraw = QPushButton('Redraw Training Labels', self)
self.redraw.setToolTip(
'draws any existing training labels in memory onto the canvas')
self.redraw.clicked.connect(self.canvas2.redrawLabels)
self.button_lay.addWidget(self.redraw)
self.train = QPushButton('train classifier', self)
self.train.pressed.connect(self.train_classifier)
self.button_lay.addWidget(self.train)
self.clear = QPushButton('Clear Canvas', self)
self.clear.setToolTip(
'Removes any generated segmentation masks and labels from the image, does not clear training labels from memory'
)
self.clear.clicked.connect(self.canvas2.clearCanvas)
self.button_lay.addWidget(self.clear)
self.getarrayc = QPushButton('Save and Close', self)
self.getarrayc.clicked.connect(self.save_and_close)
self.button_lay.addWidget(self.getarrayc)
self.tab3.setLayout(lay3)
self.show()
def updateLocalSize(self):
if self.comboBox.currentText(
) == 'Niblack' or self.comboBox.currentText(
) == 'Sauvola' or self.comboBox.currentText() == 'Local':
self.local_size.setEnabled(True)
self.local_size.setMinimum(1)
self.local_size.setSingleStep(2)
self.local_size.setMaximum(self.image.shape[0])
elif self.comboBox.currentText(
) == "Local Otsu" or self.comboBox.currentText(
) == "Local+Global Otsu":
self.local_size.setEnabled(True)
self.local_size.setMaximum(self.image.shape[0])
else:
self.local_size.setEnabled(False)
def getim(self, im_hs):
self.im_hs = im_hs
im = im_hs.data.astype(np.float64)
im = im - np.min(im)
image = np.uint8(255 * im / np.max(im))
self.image = image
def getparams(self):
self.params = parameters()
self.params.generate()
def changeIm(self):
if str(self.imBox.currentText()) == "Image":
self.imflag = "Image"
if str(self.imBox.currentText()) == "Labels":
self.imflag = "Labels"
def changeWatershed(self, state):
if state == Qt.Checked:
self.params.segment['watershed'] = True
self.watershed_erosion.setEnabled(True)
self.watershed_size.setEnabled(True)
else:
self.params.segment['watershed'] = False
self.watershed_erosion.setEnabled(False)
self.watershed_size.setEnabled(False)
def changeInvert(self, state):
if state == Qt.Checked:
self.params.segment['invert'] = True
qi = QImage(
invert(self.image).data, self.image.shape[1],
self.image.shape[0], self.image.shape[1],
QImage.Format_Indexed8)
else:
self.params.segment['invert'] = False
qi = QImage(self.image.data, self.image.shape[1],
self.image.shape[0], self.image.shape[1],
QImage.Format_Indexed8)
pixmap = QPixmap(qi)
self.pixmap2 = pixmap.scaled(self.canvas_size, self.canvas_size,
Qt.KeepAspectRatio)
self.label.setPixmap(self.pixmap2)
def rollingball(self):
if self.sp.value() == 1:
self.params.segment['rb_kernel'] = 0
else:
self.params.segment['rb_kernel'] = self.sp.value()
def gaussian(self):
self.params.segment['gaussian'] = self.gauss.value()
def local(self):
self.params.segment['local_size'] = self.local_size.value()
def watershed(self):
self.params.segment['watershed_size'] = self.watershed_size.value()
def watershed_e(self):
self.params.segment[
'watershed_erosion'] = self.watershed_erosion.value()
def minsize(self):
self.params.segment['min_size'] = self.minsizev.value()
def update(self):
labels = process(self.im_hs, self.params)
labels = np.uint8(labels * (256 / labels.max()))
if self.imflag == "Image":
#b=image
b = np.uint8(
mark_boundaries(self.image, labels, color=(1, 1, 1))[:, :, 0] *
255)
if self.params.segment['invert'] == True:
qi = QImage(
invert(b).data, b.shape[1], b.shape[0], b.shape[1],
QImage.Format_Indexed8)
else:
qi = QImage(b.data, b.shape[1], b.shape[0], b.shape[1],
QImage.Format_Indexed8)
if self.imflag == "Labels":
qi = QImage(labels.data, labels.shape[1], labels.shape[0],
labels.shape[1], QImage.Format_Indexed8)
#qi = QImage(imchoice.data, imchoice.shape[1], imchoice.shape[0], imchoice.shape[1], QImage.Format_Indexed8)
pixmap = QPixmap(qi)
pixmap2 = pixmap.scaled(self.canvas_size, self.canvas_size,
Qt.KeepAspectRatio)
self.label.setPixmap(pixmap2)
self.prev_params.load()
self.prev_params.save(
filename=os.path.dirname(inspect.getfile(process)) +
'/parameters/parameters_previous.hdf5')
self.params.save()
def undo(self):
self.params.load(filename='parameters/parameters_previous.hdf5')
labels = process(self.im_hs, self.params)
labels = np.uint8(labels * (256 / labels.max()))
if self.imflag == "Image":
#b=image
b = np.uint8(
mark_boundaries(self.image, labels, color=(1, 1, 1))[:, :, 0] *
255)
qi = QImage(b.data, b.shape[1], b.shape[0], b.shape[1],
QImage.Format_Indexed8)
if self.imflag == "Labels":
qi = QImage(labels.data, labels.shape[1], labels.shape[0],
labels.shape[1], QImage.Format_Indexed8)
#qi = QImage(imchoice.data, imchoice.shape[1], imchoice.shape[0], imchoice.shape[1], QImage.Format_Indexed8)
pixmap = QPixmap(qi)
pixmap2 = pixmap.scaled(self.canvas_size, self.canvas_size,
Qt.KeepAspectRatio)
self.label.setPixmap(pixmap2)
def return_params(self, params):
print(self.params.segment)
def threshold_choice(self):
if str(self.comboBox.currentText()) == "Otsu":
self.params.segment['threshold'] = "otsu"
elif str(self.comboBox.currentText()) == "Mean":
self.params.segment['threshold'] = "mean"
elif str(self.comboBox.currentText()) == "Minimum":
self.params.segment['threshold'] = "minimum"
elif str(self.comboBox.currentText()) == "Yen":
self.params.segment['threshold'] = "yen"
elif str(self.comboBox.currentText()) == "Isodata":
self.params.segment['threshold'] = "isodata"
elif str(self.comboBox.currentText()) == "Li":
self.params.segment['threshold'] = "li"
elif str(self.comboBox.currentText()) == "Local":
self.params.segment['threshold'] = "local"
elif str(self.comboBox.currentText()) == "Local Otsu":
self.params.segment['threshold'] = "local_otsu"
elif str(self.comboBox.currentText()) == "Local+Global Otsu":
self.params.segment['threshold'] = "lg_otsu"
elif str(self.comboBox.currentText()) == "Niblack":
self.params.segment['threshold'] = "niblack"
elif str(self.comboBox.currentText()) == "Sauvola":
self.params.segment['threshold'] = "sauvola"
def toggle_fk(self, tool):
if tool == 'Gaussian':
self.tsparams.gaussian[0] = not self.tsparams.gaussian[0]
elif tool == 'Diff. Gaussians':
self.tsparams.diff_gaussian[0] = not self.tsparams.diff_gaussian[0]
elif tool == 'Median':
self.tsparams.median[0] = not self.tsparams.median[0]
elif tool == 'Minimum':
self.tsparams.minimum[0] = not self.tsparams.minimum[0]
elif tool == 'Maximum':
self.tsparams.maximum[0] = not self.tsparams.maximum[0]
elif tool == 'Sobel':
self.tsparams.sobel[0] = not self.tsparams.sobel[0]
elif tool == 'Hessian':
self.tsparams.hessian[0] = not self.tsparams.hessian[0]
elif tool == 'Laplacian':
self.tsparams.laplacian[0] = not self.tsparams.laplacian[0]
elif tool == 'M-Sum':
self.tsparams.membrane[1] = not self.tsparams.membrane[1]
elif tool == 'M-Mean':
self.tsparams.membrane[2] = not self.tsparams.membrane[2]
elif tool == 'M-Standard Deviation':
self.tsparams.membrane[3] = not self.tsparams.membrane[3]
elif tool == 'M-Median':
self.tsparams.membrane[4] = not self.tsparams.membrane[4]
elif tool == 'M-Minimum':
self.tsparams.membrane[5] = not self.tsparams.membrane[5]
elif tool == 'M-Maximum':
self.tsparams.membrane[6] = not self.tsparams.membrane[6]
def change_sigma(self):
self.tsparams.set_global_sigma(self.spinb1.value())
def change_high_sigma(self):
self.tsparams.diff_gaussian[3] = self.spinb2.value()
def change_disk(self):
self.tsparams.set_global_disk_size(self.spinb3.value())
def classifier_choice(self):
if str(self.comboBox.currentText()) == "Random Forest":
self.classifier = RandomForestClassifier(n_estimators=200)
elif str(self.comboBox.currentText()) == "Nearest Neighbours":
self.classifier = KNeighborsClassifier()
elif str(self.comboBox.currentText()) == "Naive Bayes":
self.classifier = GaussianNB()
elif str(self.comboBox.currentText()) == "QDA":
self.classifier = QuadraticDiscriminantAnalysis()
def train_classifier(self):
array = self.canvas2.array
self.mask = np.array(
Image.fromarray(array).resize(
(self.image.shape[1], self.image.shape[0])))
self.trained_mask, self.classifier = cluster_trained(
self.im_hs, self.mask, self.classifier, self.tsparams)
self.canvas2.clearCanvas()
if self.trained_mask.any() != 0:
self.canvas2.drawLabels(self.trained_mask)
def save_array(self):
self.canvas.savearray(self.image)
def save_and_close(self):
array = self.canvas2.array
self.mask = np.array(
Image.fromarray(array).resize(
(self.image.shape[1], self.image.shape[0])))
self.canvas2.savearray(self.image)
self.close()
class MainFrame(QWidget):
SETTING_FILE = 'settings.json'
INFO_FILE = 'info.csv'
PATHS = []
def __init__(self, parent=None):
super().__init__(parent=parent)
self.parent = parent
self.parent.setWindowIcon(QIcon('music-note.png'))
self.parent.setWindowTitle('XRhythm')
self.setupUI()
def setupUI(self):
self.qhbox = QHBoxLayout(self)
self.group_box_input = QGroupBox('Input', self)
self.grid_layout = QGridLayout()
self.group_box_input.setLayout(self.grid_layout)
self.label_name = QLabel('Tên nhạc:')
self.line_name = QLineEdit()
self.label_quality = QLabel('Chất lượng: ')
self.bttgrp = QButtonGroup()
self.radio_128 = QRadioButton('128kbps')
self.radio_320 = QRadioButton('320kbps')
self.bttgrp.addButton(self.radio_128, 0)
self.bttgrp.addButton(self.radio_320, 1)
self.label_save = QLabel('Lưu ở:')
self.combobox_save = QComboBox(self)
self.btt_browse = QPushButton('Duyệt...')
self.btt_browse.clicked.connect(self.browse)
self.btt_download = QPushButton('Tải')
self.btt_download.clicked.connect(self.download)
self.grid_layout.addWidget(self.label_name, 0, 0)
self.grid_layout.addWidget(self.line_name, 0, 1, 1, 2)
self.grid_layout.addWidget(self.label_quality, 1, 0)
self.grid_layout.addWidget(self.radio_128, 1, 1)
self.grid_layout.addWidget(self.radio_320, 1, 2)
self.grid_layout.addWidget(self.label_save, 2, 0)
self.grid_layout.addWidget(self.combobox_save, 2, 1)
self.grid_layout.addWidget(self.btt_browse, 2, 2)
self.grid_layout.addWidget(self.btt_download, 3, 0, 1, 3)
self.qhbox.addWidget(self.group_box_input)
self.setLayout(self.qhbox)
self.group_box_result = QGroupBox('Result', self)
self.qvbox_group_box_result = QVBoxLayout(self)
self.group_box_result.setLayout(self.qvbox_group_box_result)
self.table = QTableView(self.group_box_result)
self.qvbox_group_box_result.addWidget(self.table)
self.qhbox.addWidget(self.group_box_result)
self.readSettingFile()
def createSettingFile(self):
with open(MainFrame.SETTING_FILE, 'r') as settingFile:
settings = json.load(settingFile)
if self.radio_128.isChecked():
quality = '128'
else:
quality = '320'
# get list items in combobox
items = []
for i in range(self.combobox_save.count()):
items.append(self.combobox_save.itemText(i))
settings['quality'] = quality
settings['list_path'] = items
settings['choice'] = self.combobox_save.currentIndex()
with open(MainFrame.SETTING_FILE, 'w') as settingFile:
json.dump(settings, settingFile)
def readSettingFile(self):
with open(MainFrame.SETTING_FILE, 'r') as settingFile:
settings = json.load(settingFile)
if settings['quality'] == '128':
self.radio_128.setChecked(True)
else:
self.radio_320.setChecked(True)
for i in settings['list_path']:
self.combobox_save.addItem(i)
self.combobox_save.setCurrentIndex(settings['choice'])
def browse(self):
path = QFileDialog.getExistingDirectory(self, 'Chọn nơi lưu')
self.combobox_save.addItem(path)
self.combobox_save.setCurrentIndex(self.combobox_save.count() - 1)
def download(self):
print('download')
if self.line_name.text() == '':
QMessageBox.warning(self, 'Thông báo',
'Bạn chưa nhập tên bài hát!')
return
if self.radio_128.isChecked():
quality = '128'
else:
quality = '320'
self.download_thread = DownloaderThread(
self.line_name.text(), quality, self.combobox_save.currentText())
self.download_thread.signal.connect(self.writeToCsvFile)
self.download_thread.start()
def writeToCsvFile(self, music_object: music_object):
with open(self.INFO_FILE, 'a', encoding='utf-8') as info_file:
infoWriter = csv.writer(info_file)
infoWriter.writerow(music_object.getListInfo())
self.updateTable()
def showMessage(self, name_music):
self.msg_successful = QMessageBox.information(
self, 'Thông báo cute', 'Đã tải xong bài ' + name_music)
questions_list.append(Question("Один известный писатель рассказывал, что списал образ старушки-вредины со своей бывшей жены.\n При этом бабулька оказалась удивительно похожей на Коко Шанель. На голове у нее всегда была\n шляпка со складной тульей, благодаря которой она и получила прозвище...", 'Шапокляк', 'Красная Шапочка', 'Мадам Баттерфляй', 'Мадам Кошанель','Правильный ответ - Шапокляк.'))
#questions_list.append(Question("", '', '', '', '',''))
app = QApplication([]) #Создаём приложение.
btn_OK = QPushButton('Ответить') #Создаём виджет кнопку с надписью "Ответить"
lb_Question = QLabel('Самый сложный вопрос в мире!') #Создаём виджет Текст "Самый сложный вопрос."
RadioGroupBox = QGroupBox("Варианты ответов") #Конструктор для создания группы радио кнопок.
#Выделяется визуально!
rbtn_1 = QRadioButton('Вариант 1')
rbtn_2 = QRadioButton('Вариант 2') #Создаём 4 радиокнопки для вариантов ответа.
rbtn_3 = QRadioButton('Вариант 3')
rbtn_4 = QRadioButton('Вариант 4')
RadioGroup = QButtonGroup() #Все переключатели объединяем в специальную группу.
RadioGroup.addButton(rbtn_1) #Теперь может быть выбран только один из них.
RadioGroup.addButton(rbtn_2)
RadioGroup.addButton(rbtn_3)
RadioGroup.addButton(rbtn_4)
layout_ans1 = QHBoxLayout() #Создаём горизантальную линию в группе.
layout_ans2 = QVBoxLayout() #Создаём вертикальную линию в группе.
layout_ans3 = QVBoxLayout() #Создаём вертикальную линию в группе.
layout_ans2.addWidget(rbtn_1)
layout_ans2.addWidget(rbtn_2)
layout_ans3.addWidget(rbtn_3)
layout_ans3.addWidget(rbtn_4)
layout_ans1.addLayout(layout_ans2)
layout_ans1.addLayout(layout_ans3) # разместили столбцы в одной строке
RadioGroupBox.setLayout(layout_ans1) # готова "панель" с вариантами ответов
class ToolBar(QWidget):
mouseEntered = pyqtSignal()
mouseLeft = pyqtSignal()
toolChanged = pyqtSignal(str)
primaryInkChanged = pyqtSignal(str)
secondaryInkChanged = pyqtSignal(str)
def __init__(self):
super(ToolBar, self).__init__()
self.setAttribute(Qt.WA_StaticContents)
self.setAttribute(Qt.WA_NoSystemBackground)
self.setFont(ResourcesCache.get("BigFont"))
self._registeredTools = {}
self._registeredInks = {}
self._toolSlots = []
self._inkSlots = []
self._currentActiveToolSlot = None
self._previousActiveToolSlot = None
self._currentEditedInkSlot = None
self._previousEditedInkSlot = None
self._editMode = False
self._backgroundColor = QColor(40, 40, 40)
self._toolLabelColor = QColor(112, 231, 255)
self._layout = QVBoxLayout()
self._layout.setAlignment(Qt.AlignTop)
self._layout.setContentsMargins(4, 4, 4, 4)
top_layout = QHBoxLayout()
self._layout.addLayout(top_layout)
self._toolsLayout = QHBoxLayout()
self._inksLayout = QHBoxLayout()
self._toolsLayout.setContentsMargins(0, 0, 0, 0)
self._toolsLayout.setAlignment(Qt.AlignLeft)
self._inksLayout.setContentsMargins(0, 0, 0, 0)
self._inksLayout.setAlignment(Qt.AlignRight)
top_layout.addLayout(self._toolsLayout)
top_layout.addLayout(self._inksLayout)
self._toolsButtonGroup = QButtonGroup()
self._toolsButtonGroup.buttonClicked.connect(
self._on_tool_slot_triggered)
self._inksButtonGroup = QButtonGroup()
self._inksButtonGroup.setExclusive(False)
self._inksButtonGroup.buttonClicked.connect(
self._on_ink_slot_triggered)
self.setLayout(self._layout)
self._toolbarSubPanel = None
self._toolsListWidget = None
self._toolsOptionsPanel = None
self._init_edit_panel()
self._add_ink_slot(0)
self._add_ink_slot(1)
self.resize(0, 50)
# -------------------------------------------------------------------------
def get_tool_by_name(self, name):
return self._registeredTools[name]
def register_tool(self, tool, is_default=None):
if tool.name not in self._registeredTools:
self._registeredTools[tool.name] = tool
self._toolsListWidget.addItem(tool.name)
if is_default is True:
self._toolsListWidget.setCurrentRow(0)
self._build_tool_options_pane(tool)
if len(self._toolSlots) < 4:
slot_index = self._add_tool_slot(is_default)
self._assign_tool_to_slot(tool, slot_index)
def register_ink(self, ink, slot):
if not ink.name in self._registeredInks:
self._registeredInks[ink.name] = ink
self._inksListWidget.addItem(ink.name)
self._build_ink_options_pane(ink)
if self._inkSlots[slot]['id'] is None:
self._assign_ink_to_slot(ink, slot)
def switch_tool_slot(self, slot):
self._previousActiveToolSlot = self._currentActiveToolSlot
self._currentActiveToolSlot = slot
if self._currentActiveToolSlot == self._previousActiveToolSlot:
return
tool_name = self._toolSlots[slot]['id']
self._toolSlots[slot]['button'].setChecked(True)
self.toolChanged.emit(tool_name)
self._select_tool_on_list(tool_name)
# -------------------------------------------------------------------------
def _go_back_to_last_tool(self):
self.switch_tool_slot(self._previousActiveToolSlot)
def _add_tool_slot(self, selected=None):
slot_button = QPushButton()
slot_button.setCheckable(True)
index = len(self._toolSlots)
if selected is not None and selected is True:
slot_button.setChecked(True)
slot = {'id': None, 'button': slot_button}
if selected:
self._currentActiveToolSlot = index
self._toolSlots.append(slot)
self._toolsButtonGroup.addButton(slot_button, index)
self._toolsLayout.addWidget(slot_button)
return index
def _add_ink_slot(self, slot_number):
slot_button = QPushButton()
slot_button.setFont(self.font())
slot_button.setStyleSheet(
"border-color: rgb(56,56,56); background-color: rgb(17,17,"
"17); font-size: 12pt;")
index = len(self._inkSlots)
if slot_number == 0:
icon = QIcon()
icon.addPixmap(QPixmap(":/icons/ico_mouse_button1"), QIcon.Normal,
QIcon.Off)
slot_button.setIcon(icon)
slot_button.setIconSize(QSize(18, 23))
elif slot_number == 1:
icon = QIcon()
icon.addPixmap(QPixmap(":/icons/ico_mouse_button2"), QIcon.Normal,
QIcon.Off)
slot_button.setIcon(icon)
slot_button.setIconSize(QSize(18, 23))
slot = {'id': None, 'button': slot_button}
self._inkSlots.append(slot)
self._inksButtonGroup.addButton(slot_button)
self._inksButtonGroup.setId(slot_button, index)
self._inksLayout.addWidget(slot_button)
return index
def _assign_tool_to_slot(self, tool, slot):
if slot < 0 or slot > len(self._toolSlots) - 1:
raise Exception(
'[ToolBar] > _assignToolToSlot : invalid slot parameter')
self._toolSlots[slot]['id'] = tool.name
icon = tool.icon
if icon is not None:
tool_button = self._toolSlots[slot]['button']
tool_button.setIcon(tool.icon)
tool_button.setIconSize(QSize(24, 24))
def _assign_ink_to_slot(self, ink, slot):
if slot != 0 and slot != 1:
raise Exception(
'[ToolBar] > _assignInkToSlot : invalid slot parameter')
ink_name = ink.name
self._inkSlots[slot]['id'] = ink_name
self._inkSlots[slot]['button'].setText(ink_name)
if slot == 0:
self.primaryInkChanged.emit(ink_name)
elif slot == 1:
self.secondaryInkChanged.emit(ink_name)
def _init_edit_panel(self):
self._toolbarSubPanel = QStackedWidget()
# 1. Initialize Tools Control Panel -----------------------------------
self._toolsListWidget = QListWidget()
self._toolsListWidget.currentRowChanged.connect(
lambda v: self._toolsOptionsPanel.setCurrentIndex(v))
self._toolsListWidget.setMaximumSize(QSize(150, 200))
self._toolsListWidget.itemClicked.connect(
self._on_tool_list_item_clicked)
# Tools Subpanel ------------------------------------------------------
tools_control_panel = QWidget()
tools_control_panel_layout = QHBoxLayout()
tools_control_panel.setLayout(tools_control_panel_layout)
tools_control_panel_layout.setAlignment(Qt.AlignLeft)
# Tools List ----------------------------------------------------------
tools_list_sublayout = QVBoxLayout()
tools_list_sublayout.setAlignment(Qt.AlignTop)
tools_list_sublayout.setContentsMargins(0, 0, 0, 0)
tools_list_sublayout.addWidget(QLabel("Tools"))
tools_list_sublayout.addWidget(self._toolsListWidget)
tools_control_panel_layout.addLayout(tools_list_sublayout)
# Tools Options -------------------------------------------------------
tools_options_sublayout = QVBoxLayout()
tools_options_sublayout.setAlignment(Qt.AlignTop)
tools_control_panel_layout.addLayout(tools_options_sublayout)
self._toolsOptionsPanel = QStackedWidget()
tools_options_sublayout.addWidget(QLabel("Tools Options"))
tools_options_sublayout.addWidget(self._toolsOptionsPanel)
self._toolbarSubPanel.addWidget(tools_control_panel)
# 2. Initialize Inks Control Panel ------------------------------------
self._inksListWidget = QListWidget()
self._inksListWidget.currentRowChanged.connect(
lambda v: self._inksOptionsPanel.setCurrentIndex(v))
self._inksListWidget.setMaximumSize(QSize(150, 200))
self._inksListWidget.itemClicked.connect(
self._on_ink_list_item_clicked)
# Inks Subpanel -------------------------------------------------------
inks_control_panel = QWidget()
inks_control_panel_layout = QHBoxLayout()
inks_control_panel.setLayout(inks_control_panel_layout)
inks_control_panel_layout.setAlignment(Qt.AlignLeft)
# Inks List -----------------------------------------------------------
inks_list_sublayout = QVBoxLayout()
inks_list_sublayout.setAlignment(Qt.AlignTop)
inks_list_sublayout.setContentsMargins(0, 0, 0, 0)
inks_list_sublayout.addWidget(QLabel("Inks"))
inks_list_sublayout.addWidget(self._inksListWidget)
inks_control_panel_layout.addLayout(inks_list_sublayout)
# Inks Options --------------------------------------------------------
inks_options_sublayout = QVBoxLayout()
inks_options_sublayout.setAlignment(Qt.AlignTop)
inks_control_panel_layout.addLayout(inks_options_sublayout)
self._inksOptionsPanel = QStackedWidget()
inks_options_sublayout.addWidget(QLabel("Ink Options"))
inks_options_sublayout.addWidget(self._inksOptionsPanel)
self._toolbarSubPanel.addWidget(inks_control_panel)
# ---------------------------------------------------------------------
self._layout.addWidget(self._toolbarSubPanel)
self._toolbarSubPanel.setVisible(False)
def _build_tool_options_pane(self, tool):
pane = QWidget()
pane_layout = QVBoxLayout()
pane_layout.setAlignment(Qt.AlignTop)
pane.setLayout(pane_layout)
for prop in tool.properties.values():
field_layout = QHBoxLayout()
field_layout.addWidget(QLabel(prop.description))
prop_widget = prop.build_property_widget()
field_layout.addWidget(prop_widget)
pane_layout.addLayout(field_layout)
self._toolsOptionsPanel.addWidget(pane)
def _build_ink_options_pane(self, ink):
pane = QWidget()
pane_layout = QVBoxLayout()
pane_layout.setAlignment(Qt.AlignTop)
pane.setLayout(pane_layout)
for prop in ink.properties.values():
field_layout = QHBoxLayout()
field_layout.addWidget(QLabel(prop.description))
prop_widget = prop.build_property_widget()
field_layout.addWidget(prop_widget)
pane_layout.addLayout(field_layout)
self._inksOptionsPanel.addWidget(pane)
def _select_tool_on_list(self, tool_name):
tool_list_item = \
self._toolsListWidget.findItems(tool_name, Qt.MatchExactly)[0]
if tool_list_item is not None:
self._toolsListWidget.setCurrentItem(tool_list_item)
def _select_ink_on_list(self, ink_name):
ink_list_item = \
self._inksListWidget.findItems(ink_name, Qt.MatchExactly)[0]
if ink_list_item is not None:
self._inksListWidget.setCurrentItem(ink_list_item)
def _toggle_edit_mode(self):
if not self._editMode:
self._show_sub_panel()
else:
self._hide_sub_panel()
self.update()
def _show_sub_panel(self):
self._editMode = True
self.resize(self.width(), 300)
self._toolbarSubPanel.setVisible(True)
def _hide_sub_panel(self):
self._editMode = False
self.resize(self.width(), 50)
self._toolbarSubPanel.setVisible(False)
self._finish_ink_edit_mode()
def _finish_ink_edit_mode(self):
if self._currentEditedInkSlot is not None:
self._inksButtonGroup.button(self._currentEditedInkSlot). \
setStyleSheet("border-color: rgb(56,56,56);")
self._currentEditedInkSlot = None
self._previousEditedInkSlot = None
self._inksListWidget.setCurrentRow(0)
self._toolbarSubPanel.setCurrentIndex(0)
# -------------------------------------------------------------------------
def mousePressEvent(self, e):
self._toggle_edit_mode()
e.accept()
def wheelEvent(self, e):
e.accept()
def enterEvent(self, e):
self.mouseEntered.emit()
self.setCursor(Qt.PointingHandCursor)
def leaveEvent(self, e):
self.mouseLeft.emit()
def _on_tool_slot_triggered(self):
self._toolbarSubPanel.setCurrentIndex(0)
triggered_slot = self._toolsButtonGroup.checkedId()
if self._currentEditedInkSlot is not None:
self._finish_ink_edit_mode()
self.switch_tool_slot(triggered_slot)
self.update()
def _on_ink_slot_triggered(self, slot_button):
if not self._editMode:
self._show_sub_panel()
triggered_slot_id = self._inksButtonGroup.id(slot_button)
if triggered_slot_id != self._currentEditedInkSlot:
self._previousEditedInkSlot = self._currentEditedInkSlot
self._currentEditedInkSlot = triggered_slot_id
if self._previousEditedInkSlot is not None:
self._inksButtonGroup. \
button(self._previousEditedInkSlot). \
setStyleSheet("border-color: rgb(56,56,56);")
slot_button.setStyleSheet("border-color: rgb(255,0,0);")
self._toolbarSubPanel.setCurrentIndex(1)
ink_name = self._inkSlots[triggered_slot_id]['id']
self._select_ink_on_list(ink_name)
if triggered_slot_id == 0:
self.primaryInkChanged.emit(ink_name)
elif triggered_slot_id == 1:
self.secondaryInkChanged.emit(ink_name)
else:
self._hide_sub_panel()
def _on_tool_list_item_clicked(self, new_item):
new_item_name = new_item.text()
self._assign_tool_to_slot(self.get_tool_by_name(new_item_name),
self._currentActiveToolSlot)
self.toolChanged.emit(new_item_name)
self._toolbarSubPanel.update()
def _on_ink_list_item_clicked(self, item):
item_name = item.text()
ink = self._registeredInks[item_name]
if ink is not None:
self._assign_ink_to_slot(ink, self._currentEditedInkSlot)
class exampleQMainWindow (QWidget):
def __init__(self):
super(exampleQMainWindow, self).__init__()
# Create QListWidget
self.myQListWidget = QListWidget(self)
self.myQListWidget.setStyleSheet("""
QListWidget:item:selected:active {
background-color:#A6A4FF;}
""")
self.setMinimumSize(350, 500)
self.config = configparser.ConfigParser()
self.config.read('prefs.cfg')
self.extention = QLineEdit()
self.filename = QLineEdit()
self.add_type = QPushButton("add type")
self.del_type = QPushButton("del type")
self.color_button = color_picker(parent=self)
self.pattern_icon = Pattern_button(parent=self)
self.radio_button_one = QRadioButton('Classic')
self.radio_button_two = QRadioButton('Magellan')
self.radio_group = QGroupBox('operation mode')
self.radio_group.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.pattern_group = QGroupBox('window pattern and text color')
self.pattern_group.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.button_group = QButtonGroup()
self.button_group.addButton(self.radio_button_one)
self.button_group.addButton(self.radio_button_two)
self.button_group.setId(self.radio_button_one, 1)
self.button_group.setId(self.radio_button_two, 2)
self.mainlayout = QVBoxLayout()
self.holdgroups_layout = QHBoxLayout()
self.radio_button_layout = QVBoxLayout()
self.pattern_label_layout = QHBoxLayout()
self.add_filetype_layout = QFormLayout()
self.add_del_button_layout = QHBoxLayout()
# adding
self.holdgroups_layout.addWidget(self.radio_group)
self.holdgroups_layout.addWidget(self.pattern_group)
self.pattern_label_layout.addWidget(self.pattern_icon)
self.pattern_label_layout.addStretch(1)
self.pattern_label_layout.addWidget(self.color_button)
self.pattern_label_layout.addStretch(1)
self.pattern_group.setLayout(self.pattern_label_layout)
self.radio_button_layout.addWidget(self.radio_button_one)
self.radio_button_layout.addWidget(self.radio_button_two)
self.radio_group.setLayout(self.radio_button_layout)
self.add_filetype_layout.addRow('extention', self.extention)
self.add_filetype_layout.addRow('path to icon', self.filename)
self.add_del_button_layout.addWidget(self.add_type)
self.add_del_button_layout.addWidget(self.del_type)
# layouts settings
# self.radio_button_layout.setGeometry(QRect(10, 10, 10, 10))
self.add_filetype_layout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
# self.pattern_icon.setPixmap(QPixmap("./images/pattern.png").scaledToWidth(80))
self.mainlayout.setContentsMargins(5, 5, 5, 0)
self.mainlayout.setSpacing(7)
# reading stored settings
for key, value in self.config.items('icons'):
myQCustomQWidget = QCustomQWidget()
myQCustomQWidget.setTextUp("filetype: " + key.upper())
myQCustomQWidget.setTextDown(value)
myQCustomQWidget.setIcon(os.path.dirname(os.path.realpath(__file__)) + value)
myQListWidgetItem = QListWidgetItem(self.myQListWidget)
myQListWidgetItem.setSizeHint(myQCustomQWidget.sizeHint())
self.myQListWidget.addItem(myQListWidgetItem)
self.myQListWidget.setItemWidget(myQListWidgetItem, myQCustomQWidget)
# adding elements to layout
self.mainlayout.addLayout(self.holdgroups_layout)
self.mainlayout.insertSpacing(10, 10)
self.mainlayout.addWidget(self.myQListWidget)
self.mainlayout.addLayout(self.add_filetype_layout)
self.mainlayout.addLayout(self.add_del_button_layout)
self.setLayout(self.mainlayout)
def request_trezor_init_settings(self, wizard, method, device_id):
vbox = QVBoxLayout()
next_enabled = True
devmgr = self.device_manager()
client = devmgr.client_by_id(device_id)
if not client:
raise Exception(_("The device was disconnected."))
model = client.get_trezor_model()
fw_version = client.client.version
capabilities = client.client.features.capabilities
have_shamir = Capability.Shamir in capabilities
# label
label = QLabel(_("Enter a label to name your device:"))
name = QLineEdit()
hl = QHBoxLayout()
hl.addWidget(label)
hl.addWidget(name)
hl.addStretch(1)
vbox.addLayout(hl)
# Backup type
gb_backuptype = QGroupBox()
hbox_backuptype = QHBoxLayout()
gb_backuptype.setLayout(hbox_backuptype)
vbox.addWidget(gb_backuptype)
gb_backuptype.setTitle(_('Select backup type:'))
bg_backuptype = QButtonGroup()
rb_single = QRadioButton(gb_backuptype)
rb_single.setText(_('Single seed (BIP39)'))
bg_backuptype.addButton(rb_single)
bg_backuptype.setId(rb_single, BackupType.Bip39)
hbox_backuptype.addWidget(rb_single)
rb_single.setChecked(True)
rb_shamir = QRadioButton(gb_backuptype)
rb_shamir.setText(_('Shamir'))
bg_backuptype.addButton(rb_shamir)
bg_backuptype.setId(rb_shamir, BackupType.Slip39_Basic)
hbox_backuptype.addWidget(rb_shamir)
rb_shamir.setEnabled(Capability.Shamir in capabilities)
rb_shamir.setVisible(False) # visible with "expert settings"
rb_shamir_groups = QRadioButton(gb_backuptype)
rb_shamir_groups.setText(_('Super Shamir'))
bg_backuptype.addButton(rb_shamir_groups)
bg_backuptype.setId(rb_shamir_groups, BackupType.Slip39_Advanced)
hbox_backuptype.addWidget(rb_shamir_groups)
rb_shamir_groups.setEnabled(Capability.ShamirGroups in capabilities)
rb_shamir_groups.setVisible(False) # visible with "expert settings"
# word count
word_count_buttons = {}
gb_numwords = QGroupBox()
hbox1 = QHBoxLayout()
gb_numwords.setLayout(hbox1)
vbox.addWidget(gb_numwords)
gb_numwords.setTitle(_("Select seed/share length:"))
bg_numwords = QButtonGroup()
for count in (12, 18, 20, 24, 33):
rb = QRadioButton(gb_numwords)
word_count_buttons[count] = rb
rb.setText(_("{:d} words").format(count))
bg_numwords.addButton(rb)
bg_numwords.setId(rb, count)
hbox1.addWidget(rb)
rb.setChecked(True)
def configure_word_counts():
if model == "1":
checked_wordcount = 24
else:
checked_wordcount = 12
if method == TIM_RECOVER:
if have_shamir:
valid_word_counts = (12, 18, 20, 24, 33)
else:
valid_word_counts = (12, 18, 24)
elif rb_single.isChecked():
valid_word_counts = (12, 18, 24)
gb_numwords.setTitle(_('Select seed length:'))
else:
valid_word_counts = (20, 33)
checked_wordcount = 20
gb_numwords.setTitle(_('Select share length:'))
word_count_buttons[checked_wordcount].setChecked(True)
for c, btn in word_count_buttons.items():
btn.setVisible(c in valid_word_counts)
bg_backuptype.buttonClicked.connect(configure_word_counts)
configure_word_counts()
# set up conditional visibility:
# 1. backup_type is only visible when creating new seed
gb_backuptype.setVisible(method == TIM_NEW)
# 2. word_count is not visible when recovering on TT
if method == TIM_RECOVER and model != "1":
gb_numwords.setVisible(False)
# PIN
cb_pin = QCheckBox(_('Enable PIN protection'))
cb_pin.setChecked(True)
vbox.addWidget(WWLabel(RECOMMEND_PIN))
vbox.addWidget(cb_pin)
# "expert settings" button
expert_vbox = QVBoxLayout()
expert_widget = QWidget()
expert_widget.setLayout(expert_vbox)
expert_widget.setVisible(False)
expert_button = QPushButton(_("Show expert settings"))
def show_expert_settings():
expert_button.setVisible(False)
expert_widget.setVisible(True)
rb_shamir.setVisible(True)
rb_shamir_groups.setVisible(True)
expert_button.clicked.connect(show_expert_settings)
vbox.addWidget(expert_button)
# passphrase
passphrase_msg = WWLabel(PASSPHRASE_HELP_SHORT)
passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
passphrase_warning.setStyleSheet("color: red")
cb_phrase = QCheckBox(_('Enable passphrases'))
cb_phrase.setChecked(False)
expert_vbox.addWidget(passphrase_msg)
expert_vbox.addWidget(passphrase_warning)
expert_vbox.addWidget(cb_phrase)
# ask for recovery type (random word order OR matrix)
bg_rectype = None
if method == TIM_RECOVER and model == '1':
gb_rectype = QGroupBox()
hbox_rectype = QHBoxLayout()
gb_rectype.setLayout(hbox_rectype)
expert_vbox.addWidget(gb_rectype)
gb_rectype.setTitle(_("Select recovery type:"))
bg_rectype = QButtonGroup()
rb1 = QRadioButton(gb_rectype)
rb1.setText(_('Scrambled words'))
bg_rectype.addButton(rb1)
bg_rectype.setId(rb1, RecoveryDeviceType.ScrambledWords)
hbox_rectype.addWidget(rb1)
rb1.setChecked(True)
rb2 = QRadioButton(gb_rectype)
rb2.setText(_('Matrix'))
bg_rectype.addButton(rb2)
bg_rectype.setId(rb2, RecoveryDeviceType.Matrix)
hbox_rectype.addWidget(rb2)
# no backup
cb_no_backup = None
if method == TIM_NEW:
cb_no_backup = QCheckBox(f'''{_('Enable seedless mode')}''')
cb_no_backup.setChecked(False)
if (model == '1' and fw_version >= (1, 7, 1)
or model == 'T' and fw_version >= (2, 0, 9)):
cb_no_backup.setToolTip(SEEDLESS_MODE_WARNING)
else:
cb_no_backup.setEnabled(False)
cb_no_backup.setToolTip(_('Firmware version too old.'))
expert_vbox.addWidget(cb_no_backup)
vbox.addWidget(expert_widget)
wizard.exec_layout(vbox, next_enabled=next_enabled)
return TrezorInitSettings(
word_count=bg_numwords.checkedId(),
label=name.text(),
pin_enabled=cb_pin.isChecked(),
passphrase_enabled=cb_phrase.isChecked(),
recovery_type=bg_rectype.checkedId() if bg_rectype else None,
backup_type=bg_backuptype.checkedId(),
no_backup=cb_no_backup.isChecked() if cb_no_backup else False,
)
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.name = 'main_window'
self.data = {}
self.adding_new_data = True # inside initialization process. Avoid refresh_plot too many times
self.mat_loaded = False
self.show_inversed_tos = False
self.show_inversed_strainmat = False
self.strainCurvesViewer = None
# self.setStyleSheet("background-color: white;")
self.init_UI()
#self.saveFileDialog()
self.setAcceptDrops(True)
self.setWindowTitle('Strain Matrix Viewer')
# self.setDragEnabled(True)
self.show()
def init_UI(self):
# print(getScreenSize())
# screenHeight, screenWidth = getScreenSize()
# self.setMaximumWidth(screenWidth//2)
# self.setMaximumHeight(screenHeight//2)
# 1. Base layout: hbox
baseHBox = QHBoxLayout()
# 2. Left panel: annotation canvas
annoVBox = QVBoxLayout()
self.sc = MplCanvas(self, width=10, height=4, dpi=100)
# self.sc.axes.pcolor(np.zeros((32,32)), cmap='jet')
self.sc.axes.text(0.5, 0.5, 'Drag & drop .mat file here to import', ha="center", va="center")
# self.sc.axes.autoscale(False)
self.sc.mpl_connect('button_press_event', self.clicked)
toolbar = NavigationToolbar(self.sc, self)
# self.setCentralWidget(toolbar)
# layout = QtWidgets.QVBoxLayout()
# layout.addWidget(toolbar)
annoVBox.addWidget(self.sc)
annoVBox.addWidget(toolbar)
self.TOS_Label = QLabel()
self.TOS_Label.setText('TOS(N): ')
self.TOS_Label.setFixedHeight(20)
self.TOS_Label.setAlignment(Qt.Qt.AlignCenter | Qt.Qt.AlignVCenter)
annoVBox.addWidget(self.TOS_Label)
self.TOS_loaded_Label = QLabel()
self.TOS_loaded_Label.setText('TOS(L): ')
self.TOS_loaded_Label.setFixedHeight(20)
self.TOS_loaded_Label.setAlignment(Qt.Qt.AlignCenter | Qt.Qt.AlignVCenter)
annoVBox.addWidget(self.TOS_loaded_Label)
# baseHBox.addWidget(self.sc)
baseHBox.addLayout(annoVBox)
# 3. Right panel: settings and tools
toolsVBox = QVBoxLayout()
# toolsVBoxWidth = 150
toolsVBoxWidth = 250
# toolsVBox.setFixedWidth(80)
# 3.0 Resulution
reso_group_box = QGroupBox("Segment Resolution")
self.reso_btn_box = QButtonGroup()
self.radio_18 = QRadioButton('18'); self.radio_18.clicked.connect(self.reso_button_toggled)
self.radio_126 = QRadioButton('126'); self.radio_126.clicked.connect(self.reso_button_toggled)
self.radio_18.setChecked(True); self.seg_reso = 18
self.radio_126.setEnabled(False)
reso_group_box_layout = QVBoxLayout()
reso_group_box_layout.addWidget(self.radio_18);self.reso_btn_box.addButton(self.radio_18, 0)
reso_group_box_layout.addWidget(self.radio_126);self.reso_btn_box.addButton(self.radio_126, 1)
reso_group_box.setLayout(reso_group_box_layout)
reso_group_box.setFixedWidth(toolsVBoxWidth)
toolsVBox.addWidget(reso_group_box)
# 3.1 Interpolation method
interp_group_box = QGroupBox("Interpolation Method")
self.interp_btn_box = QButtonGroup()
radio_linear = QRadioButton('linear'); radio_linear.clicked.connect(self.interp_button_toggled)
radio_spline = QRadioButton('spline'); radio_spline.clicked.connect(self.interp_button_toggled)
radio_spline.setChecked(True); self.interp_k = 2
interp_group_box_layout = QVBoxLayout()
interp_group_box_layout.addWidget(radio_linear);self.interp_btn_box.addButton(radio_linear, 0)
interp_group_box_layout.addWidget(radio_spline);self.interp_btn_box.addButton(radio_spline, 1)
interp_group_box.setLayout(interp_group_box_layout)
interp_group_box.setFixedWidth(toolsVBoxWidth)
toolsVBox.addWidget(interp_group_box)
# 3.2 Visibility
self.vis_strain_mat_checkBox = QCheckBox('Strain Matrix'); self.vis_strain_mat_checkBox.toggled.connect(self.vis_checkBox_toggled)
self.vis_strain_mat_denoise_checkBox = QCheckBox('Denoise'); self.vis_strain_mat_denoise_checkBox.toggled.connect(self.vis_checkBox_toggled)
self.vis_tos_new_checkBox = QCheckBox('New TOS Curve'); self.vis_tos_new_checkBox.toggled.connect(self.vis_checkBox_toggled)
self.vis_tos_loaded_checkBox = QCheckBox('Loaded TOS Curve'); self.vis_tos_loaded_checkBox.toggled.connect(self.vis_checkBox_toggled)
self.vis_tos_Jerry_checkBox = QCheckBox('Jerry TOS Curve'); self.vis_tos_Jerry_checkBox.toggled.connect(self.vis_checkBox_toggled)
self.vis_tos_otherRes_checkBox = QCheckBox('OtherRes TOS Curve'); self.vis_tos_otherRes_checkBox.toggled.connect(self.vis_checkBox_toggled)
self.vis_strain_value_limit_checkBox = QCheckBox('Strain Value Limit'); self.vis_strain_value_limit_checkBox.toggled.connect(self.vis_strain_value_limit_checkBox_toggled)
self.vis_strain_colorbar_checkBox = QCheckBox('Strain Colorbar'); self.vis_strain_colorbar_checkBox.toggled.connect(self.vis_strain_colorbar_checkBox_toggled)
self.vis_strain_mat_checkBox.setEnabled(False)
self.vis_strain_mat_denoise_checkBox.setEnabled(False)
self.vis_tos_new_checkBox.setEnabled(False)
self.vis_tos_loaded_checkBox.setEnabled(False)
self.vis_tos_otherRes_checkBox.setEnabled(False)
self.vis_strain_value_limit_checkBox.setEnabled(False)
self.vis_strain_colorbar_checkBox.setEnabled(False)
#self.vis_tos_loaded_ckeckBox.setChecked(True)
vis_group_box = QGroupBox("Visibility")
vis_group_box_layout = QVBoxLayout()
vis_group_box_layout.addWidget(self.vis_strain_mat_checkBox)
vis_group_box_layout.addWidget(self.vis_strain_mat_denoise_checkBox)
vis_group_box_layout.addWidget(self.vis_tos_new_checkBox)
vis_group_box_layout.addWidget(self.vis_tos_loaded_checkBox)
vis_group_box_layout.addWidget(self.vis_tos_Jerry_checkBox)
vis_group_box_layout.addWidget(self.vis_tos_otherRes_checkBox)
vis_group_box_layout.addWidget(self.vis_strain_value_limit_checkBox)
vis_group_box_layout.addWidget(self.vis_strain_colorbar_checkBox)
vis_group_box.setLayout(vis_group_box_layout)
vis_group_box.setFixedWidth(toolsVBoxWidth)
toolsVBox.addWidget(vis_group_box)
# Other widgets
others_group_box = QGroupBox("Others")
others_group_layout = QVBoxLayout()
# Show 3D plot
self.view_3D_button = QPushButton('View 3D')
self.view_3D_button.clicked.connect(self.view_3D_button_clicked)
self.view_3D_button.setEnabled(False)
others_group_layout.addWidget(self.view_3D_button)
# Show Strain curves
self.view_strain_curves_button = QPushButton('View Strain Curves')
self.view_strain_curves_button.clicked.connect(self.view_strain_curves_button_clicked)
self.view_strain_curves_button.setEnabled(False)
others_group_layout.addWidget(self.view_strain_curves_button)
# Append all other widgets
others_group_box.setLayout(others_group_layout)
toolsVBox.addWidget(others_group_box)
# 3.2-2 Annotator
# Layout
annotator_group_box = QGroupBox("Annotator")
annotator_group_layout = QVBoxLayout()
# Widgets
self.annotator_LE = QLineEdit()
# annotator_label = QLabel()
# annotator_label.setText('Annotator')
# annotator_group_layout.addWidget(annotator_label)
annotator_group_layout.addWidget(self.annotator_LE)
annotator_group_box.setLayout(annotator_group_layout)
annotator_group_box.setFixedWidth(toolsVBoxWidth)
toolsVBox.addWidget(annotator_group_box)
# 3.3 Export
# 3.3.1 Export .mat
export_tos_mat_group_box = QGroupBox("Export Mat")
export_tos_mat_group_layout = QVBoxLayout()
# 3.3.1.1 Filename Area
self.export_tos_mat_fname_LE = QLineEdit()
export_tos_mat_ftype_label = QLabel()
export_tos_mat_ftype_label.setText('.mat')
export_tos_mat_filename_layout = QHBoxLayout()
export_tos_mat_filename_layout.addWidget(self.export_tos_mat_fname_LE)
export_tos_mat_filename_layout.addWidget(export_tos_mat_ftype_label)
export_tos_mat_group_layout.addLayout(export_tos_mat_filename_layout)
# 3.3.1.2 TOS-only Checkbox
self.export_tos_mat_tos_only_checkBox = QCheckBox('TOS Only')
self.export_tos_mat_tos_only_checkBox.toggled.connect(self.export_tos_only_checkBox_toggled)
export_tos_mat_group_layout.addWidget(self.export_tos_mat_tos_only_checkBox)
# 3.3.1.3 Drag Label
export_tos_mat_label = DraggableLabel()
export_tos_mat_label.setText('Drag Target Folder Here')
export_tos_mat_label.setAlignment(Qt.Qt.AlignCenter | Qt.Qt.AlignVCenter)
export_tos_mat_group_layout.addWidget(export_tos_mat_label)
# 3.3.1.4 Export button
export_tos_mat_button = QPushButton()
export_tos_mat_button.setText('Export to File')
export_tos_mat_button.clicked.connect(self.export_TOS_mat)
export_tos_mat_group_layout.addWidget(export_tos_mat_button)
export_tos_mat_group_box.setLayout(export_tos_mat_group_layout)
export_tos_mat_group_box.setFixedWidth(toolsVBoxWidth)
toolsVBox.addWidget(export_tos_mat_group_box)
# 3.3.2 Export Image
export_tos_img_group_box = QGroupBox("Export img")
export_tos_img_group_layout = QVBoxLayout()
# 3.3.2.1 Filename Area
# self.app.matFilename
self.export_tos_img_fname_LE = QLineEdit()
export_tos_img_ftype_label = QLabel()
export_tos_img_ftype_label.setText('.png')
export_tos_img_filename_layout = QHBoxLayout()
export_tos_img_filename_layout.addWidget(self.export_tos_img_fname_LE)
export_tos_img_filename_layout.addWidget(export_tos_img_ftype_label)
export_tos_img_group_layout.addLayout(export_tos_img_filename_layout)
# 3.3.2.2 Drag Label
export_tos_img_label = DraggableLabel()
export_tos_img_label.setText('Drag Target Folder Here')
export_tos_img_label.setAlignment(Qt.Qt.AlignCenter | Qt.Qt.AlignVCenter)
export_tos_img_group_layout.addWidget(export_tos_img_label)
# 3.3.2.3 Export to File button
export_tos_img_button = QPushButton()
export_tos_img_button.setText('Export to File')
export_tos_img_button.clicked.connect(self.export_TOS_img)
export_tos_img_group_layout.addWidget(export_tos_img_button)
# 3.3.2.4 Export to Clipboard button
export_tos_img_cb_button = QPushButton()
export_tos_img_cb_button.setText('Copy to Clipboard')
export_tos_img_cb_button.clicked.connect(self.export_TOS_img_2clipboard)
export_tos_img_group_layout.addWidget(export_tos_img_cb_button)
export_tos_img_group_box.setLayout(export_tos_img_group_layout)
export_tos_img_group_box.setFixedWidth(toolsVBoxWidth)
toolsVBox.addWidget(export_tos_img_group_box)
# 4 Others
others_group_box = QGroupBox("Others")
others_group_layout = QVBoxLayout()
# 4.1 Inverse TOS
self.inverse_tos_checkBox = QCheckBox('Inverse TOS')
self.inverse_tos_checkBox.toggled.connect(self.inverse_tos_toggled)
others_group_layout.addWidget(self.inverse_tos_checkBox)
# 4.2 Inverse strain matrix
self.inverse_strainmat_checkBox = QCheckBox('Flip Strain Matrix')
self.inverse_strainmat_checkBox.toggled.connect(self.inverse_strainmat_toggled)
others_group_layout.addWidget(self.inverse_strainmat_checkBox)
# 4.3 Copy TOS to clipboard
# export_tos_18_cb_button = QPushButton()
# export_tos_18_cb_button.setText('Copy to Clipboard')
# export_tos_18_cb_button.clicked.connect(self.export_TOS_28_2_clipboard)
# others_group_layout.addWidget(export_tos_18_cb_button)
others_group_box.setLayout(others_group_layout)
toolsVBox.addWidget(others_group_box)
# 3.-1 Add Last strach
toolsVBox.addStretch()
baseHBox.addLayout(toolsVBox)
self.widget = QWidget()
self.widget.setLayout(baseHBox)
self.setCentralWidget(self.widget)
def reso_button_toggled(self):
# print('T!')
# print('id',self.interp_btn_box.checkedId())
if self.reso_btn_box.checkedId() == 0:
# if selected the low resolution option
self.seg_reso = 18
self.data_to_show = '18' if '18' in self.data.keys() else None
# Subsample 126 -> 18
tos_subsample = self.data['fullRes']['TOSNew'][::7]# + 7//2
self.data[self.data_to_show]['tos_from_other_reso'] = tos_subsample
elif self.reso_btn_box.checkedId() == 1:
# if selected the high resolution option
self.seg_reso = 126
self.data_to_show = 'fullRes' if 'fullRes' in self.data.keys() else None
# Interpolate 18 -> 126
xs_18 = np.linspace(1, 17, 18)
xs_126 = np.linspace(1, 17, 126)
# tos_interp = np.interp(xs_126, xs_18,self.data['18']['TOS'])
f_interp = interpolate.interp1d(xs_18,self.data['18']['TOSNew'], kind = 'quadratic')
self.data[self.data_to_show]['tos_from_other_reso'] = np.maximum(f_interp(xs_126), 17)
self.init_tos_line()
if self.mat_loaded and not self.adding_new_data:
self.refresh_plot()
def interp_button_toggled(self):
# print('T!')
# print('id',self.interp_btn_box.checkedId())
if self.interp_btn_box.checkedId() == 0:
self.interp_k = 1
elif self.interp_btn_box.checkedId() == 1:
self.interp_k = 2
if self.mat_loaded and not self.adding_new_data:
self.refresh_plot()
def vis_checkBox_toggled(self):
self.vis_strain_mat = self.vis_strain_mat_checkBox.isChecked()
self.vis_tos_loaded = self.vis_tos_loaded_checkBox.isChecked()
self.vis_tos_new = self.vis_tos_new_checkBox.isChecked()
self.vis_tos_Jerry = self.vis_tos_Jerry_checkBox.isChecked()
self.vis_tos_otherRes = self.vis_tos_otherRes_checkBox.isChecked()
if not self.adding_new_data:
self.refresh_plot()
def vis_strain_value_limit_checkBox_toggled(self):
if not self.adding_new_data:
# if self.vis_strain_colorbar_checkBox.isChecked():
# self.matplot_colobar.update_normal(mappable=self.matplot)
# self.matplot_colobar.update_bruteforce(mappable=self.matplot)
self.refresh_plot()
# if self.vis_strain_value_limit_checkBox.isChecked():
# self.
def vis_strain_colorbar_checkBox_toggled(self):
# https://stackoverflow.com/questions/5263034/remove-colorbar-from-figure-in-matplotlib
if not self.adding_new_data:
if self.vis_strain_colorbar_checkBox.isChecked():
self.matplot_colobar = self.sc.fig.colorbar(self.matplot, ax=self.sc.fig.axes)
else:
self.sc.fig.delaxes(self.sc.fig.axes[1])
self.sc.fig.subplots_adjust(right=0.90)
# self.matplot_colobar.remove()
self.refresh_plot()
def view_3D_button_clicked(self):
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
# self.window_to_open = ThreeDViewer(self)
# self.window_to_open.show()
# print("HH")
# fig, axe = plt.subplots()
# xs = np.random.rand(10)
# axe.plot(xs)
# H, W = self.data[self.data_to_show]['mat'].shape
# fig.show()
# Get strain matrix
mat = self.data[self.data_to_show]['mat']
# Create figure and 3D axis
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
# Draw 3D GT Line
# self.data[data_name]['tos_curve_sectors'] = np.arange(0.5, self.data[data_name]['NSegments']-0.5, 0.1)
# self.data[data_name]['tos_curve_frames'] = [0.5]*len(self.data[data_name]['tos_curve_sectors'])
# tos_GT_ys = np.arange(self.data[self.data_to_show]['tos_curve_sectors'])
# tos_GT_xs = np.arange(self.data[self.data_to_show]['tos_curve_frames'])
# tos_GT_zs = np.zeros(len(tos_GT_xs))
# for idx in range(len(tos_GT_xs)):
# tos_GT_zs[idx] = 0
if self.vis_strain_value_limit_checkBox.isChecked():
vmax = 0.2
vmin = -0.2
else:
vmax = None
vmin = None
mat_xs, mat_ys = np.meshgrid(np.arange(mat.shape[1]), np.arange(mat.shape[0]))
ax.plot_surface(mat_xs, mat_ys, mat, cmap='jet',
vmax = vmax, vmin = vmin,
antialiased=False, linewidth=0.2, edgecolor="dodgerblue")
# ax.plot_wireframe(mat_xs, mat_ys, mat, linewidth = 0.5)
fig.show()
def view_strain_curves_button_clicked(self):
self.strainCurvesViewer = StrainCurvesViewer(self.strainmat_to_show)
self.strainCurvesViewer.show()
def inverse_tos_toggled(self):
self.show_inversed_tos = not self.show_inversed_tos
# if self.TOS is not None:
# self.TOS = self.TOS[::-1]
# if self.tos_loaded is not None:
# self.tos_loaded = self.tos_loaded[::-1]
# for data_name in self.data.keys():
# print(data_name, self.data[data_name].keys())
# # try:
# self.data[data_name]['TOS'] = self.data[data_name]['TOS'][::-1]
# self.data[data_name]['TOSNew'] = self.data[data_name]['TOSNew'][::-1]
# except:
# pass
if not self.adding_new_data:
self.refresh_plot()
def inverse_strainmat_toggled(self):
self.show_inversed_strainmat = not self.show_inversed_strainmat
if not self.adding_new_data:
self.refresh_plot()
def export_tos_only_checkBox_toggled(self):
save_filename_main = self.export_tos_mat_fname_LE.text().replace('_tos', '')
if self.export_tos_mat_tos_only_checkBox.isChecked():
self.export_tos_mat_fname_LE.setText(save_filename_main + '_tos')
# self.export_tos_only = True
else:
self.export_tos_mat_fname_LE.setText(save_filename_main)
# self.export_tos_only = False
def clicked(self, event):
if event.button==2:
# middle click to add control point
# print('clicked!', event.xdata, event.ydata)
xdata = max(event.xdata, 0.5)
ydata = event.ydata
self.ctl_points_to_show.append(
XEllipse((xdata,ydata), self.ctl_point_to_show_w, self.ctl_point_to_show_h, fc='r', alpha=0.5)
)
self.data[self.data_to_show]['ctl_points'].append(self.ctl_points_to_show[-1])
self.update_plot()
def draw_ctl_points(self, ):
self.drs = []
for circ in self.ctl_points_to_show:
circ.width, circ.height = self.ctl_point_to_show_w, self.ctl_point_to_show_h
self.sc.axes.add_patch(circ)
dr = DraggablePoint(circ, self)
dr.connect()
self.drs.append(dr)
self.sc.draw()
def interp_given_ctrl_points(self):
if len(self.ctl_points_to_show) < 3:
return
ctl_point_frames_plot, ctl_point_sectors_plot = zip(*[circ.get_center() for circ in self.ctl_points_to_show])
order = np.argsort(ctl_point_sectors_plot)
# print(order)
ctl_point_frames_plot = [ctl_point_frames_plot[idx] for idx in order]
ctl_point_sectors_plot = [ctl_point_sectors_plot[idx] for idx in order]
# print('INTERP!')
# f = interpolate.interp1d(ctl_point_sectors, ctl_point_frames, fill_value="extrapolate", kind = self.interpolate_method)
f = make_interp_spline(ctl_point_sectors_plot, ctl_point_frames_plot, k=self.interp_k)
# self.tos_curve_sectors = np.arange(0.5, self.data[self.data_to_show]['NSegments']-0.5, 0.1)
# self.tos_curve_frames = f(self.tos_curve_sectors)
# self.tos_curve_frames[self.tos_curve_frames<0.5] = 0.5
# print(self.data.keys())
# print(self.data_to_show)
self.data[self.data_to_show]['tos_curve_sectors'] = np.arange(0.5, self.data[self.data_to_show]['NSegments']-0.5, 0.1)
self.data[self.data_to_show]['tos_curve_frames'] = np.maximum(f(self.data[self.data_to_show]['tos_curve_sectors']), 0.5)
# point at (0.5, 0.5) should have sector 0, frame 0, time 17
# self.TOS = (f(np.arange(self.data[self.data_to_show]['NSegments'])+0.5) + 0.5) * 17
# self.TOS[self.TOS < 17] = 17
self.data[self.data_to_show]['TOSNew'] = np.maximum((f(np.arange(self.data[self.data_to_show]['NSegments'])+0.5) + 0.5) * 17, 17)
# self.TOS[self.TOS < 17] = 17
# self.TOS = self.TOS[::-1]
TOSStr = ' '.join([f'{tos:.2f} ' for tos in self.data[self.data_to_show]['TOSNew']])
# self.TOS_Label.setText('TOS(N): ' + TOSStr)
#TOSStr = ' '.join([f'{tos:.2f} ' for tos in self.TOS[::-1]])
#self.TOS_Label.setText('TOS (reversed): ' + TOSStr)
def init_ctrl_points(self, event = None):
# initialize control points
scW, scH = self.sc.fig.get_size_inches()
for data_name in self.data.keys():
# self.ctl_point_to_show_w, self.ctl_point_to_show_h = 4/scH, 4/scW
ctl_point_w, ctl_point_h = \
4/scW, (self.data[data_name]['NSegments'] / 18)*(2/scH)
self.data[data_name]['ctl_point_w'], self.data[data_name]['ctl_point_h'] = \
ctl_point_w, ctl_point_h
self.data[data_name]['ctl_points'] = [
XEllipse((0.5,0.5), ctl_point_w, ctl_point_h, fc='r', alpha=0.5),
XEllipse((0.5,self.data[data_name]['NSegments']/2), ctl_point_w, ctl_point_h, fc='r', alpha=0.5),
XEllipse((0.5,self.data[data_name]['NSegments'] - 0.5), ctl_point_w, ctl_point_h, fc='r', alpha=0.5)
]
# self.interp_given_ctrl_points()
self.data[data_name]['tos_curve_sectors'] = np.arange(0.5, self.data[data_name]['NSegments']-0.5, 0.1)
self.data[data_name]['tos_curve_frames'] = [0.5]*len(self.data[data_name]['tos_curve_sectors'])
# tos_curve_sectors_init = np.arange(0.5, self.data[self.data_to_show]['NSegments']-0.5, 0.1)
# tos_curve_frames_init = [0.5]*len(tos_curve_sectors_init)
# # print(tos_curve_sectors_init, tos_curve_frames_init)
# self.tos_curve_line, = self.sc.axes.plot(tos_curve_frames_init, tos_curve_sectors_init)
# self.tos_curve_line.set_label('New')
# self.sc.axes.add_artist(self.tos_curve_line)
# def init_plot_old(self, event = None):
# # initialize control points
# scW, scH = self.sc.fig.get_size_inches()
# self.ctl_point_to_show_w, self.ctl_point_to_show_h = 4/scH, 4/scW
# # self.ctl_point_to_show_w, self.ctl_point_to_show_h = 4/scW, (self.data[self.data_to_show]['NSegments'] / 18)*(2/scH)
# self.ctl_points = [
# XEllipse((0.5,0.5), self.ctl_point_to_show_w, self.ctl_point_to_show_h, fc='r', alpha=0.5),
# XEllipse((0.5,self.data[self.data_to_show]['NSegments']/2), self.ctl_point_to_show_w, self.ctl_point_to_show_h, fc='r', alpha=0.5),
# XEllipse((0.5,self.data[self.data_to_show]['NSegments'] - 0.5), self.ctl_point_to_show_w, self.ctl_point_to_show_h, fc='r', alpha=0.5)
# ]
# # self.interp_given_ctrl_points()
# tos_curve_sectors_init = np.arange(0.5, self.data[self.data_to_show]['NSegments']-0.5, 0.1)
# tos_curve_frames_init = [0.5]*len(tos_curve_sectors_init)
# # print(tos_curve_sectors_init, tos_curve_frames_init)
# self.tos_curve_line, = self.sc.axes.plot(tos_curve_frames_init, tos_curve_sectors_init)
# self.tos_curve_line.set_label('New')
# self.sc.axes.add_artist(self.tos_curve_line)
def init_tos_line(self):
# print('init line!')
# print(self.data_to_show)
# print(len(self.data[self.data_to_show]['tos_curve_frames']))
# print(len(self.data[self.data_to_show]['tos_curve_sectors']))
self.tos_curve_line, = self.sc.axes.plot(self.data[self.data_to_show]['tos_curve_frames'], self.data[self.data_to_show]['tos_curve_sectors'])
self.tos_curve_line.set_label('New')
def update_tos_line(self, interpolate = True):
# Draw tos curve using updated control points
# print('update_tos_line')
if interpolate:
self.interp_given_ctrl_points()
tos_curve_frames_toshow = self.data[self.data_to_show]['tos_curve_frames']
if self.show_inversed_tos:
tos_curve_frames_toshow = tos_curve_frames_toshow[::-1]
self.tos_curve_line.set_xdata(tos_curve_frames_toshow)
self.tos_curve_line.set_color('r')
def update_plot(self, event = None):
# Update only ctl points and tos curve
# print('update_plot')
# print(event)
self.ctl_points_to_show = [ctl_point for ctl_point in self.data[self.data_to_show]['ctl_points'] if ctl_point.deactivated == False]
scW, scH = self.sc.fig.get_size_inches()
# print(scW, scH)
# self.ctl_point_to_show_w, self.ctl_point_to_show_h = 4/scW, 2/scH
# self.ctl_point_to_show_w, self.ctl_point_to_show_h = 1, 1
self.ctl_point_to_show_w, self.ctl_point_to_show_h = 4/scW, (self.data[self.data_to_show]['NSegments'] / 18)*(2/scH)
self.update_tos_line()
self.tos_curve_line.set_color('orange')
self.draw_ctl_points()
def refresh_plot(self):
# Redraw the whole canvas
# Clean
self.sc.axes.cla() # Clear the canvas.
# Set Title
n_words = len(self.matFilenameFull.split('/'))
title = '/'.join(self.matFilenameFull.split('/')[:int(n_words/2)]) + '\n' \
+ '/'.join(self.matFilenameFull.split('/')[int(n_words/2):])
self.sc.axes.set_title(title, fontsize = 10)
# Set limit and tick
self.sc.axes.set_xlim(0, self.data[self.data_to_show]['NFrames'])
self.sc.axes.set_ylim(0, self.data[self.data_to_show]['NSegments'])
# self.sc.axes.set_xticks(np.arange(self.data_to_show['NFrames'])+0.5)
# self.sc.axes.set_xticklabels(np.arange(self.data_to_show['NFrames']))
# self.sc.axes.set_yticks(np.arange(self.data_to_show['NSegments'])+0.5)
# self.sc.axes.set_yticklabels(np.arange(self.data_to_show['NSegments'])+1)
# self.sc.axes.autoscale(False)
# Re-draw strain matrix
if self.vis_strain_mat_checkBox.isChecked():
if self.vis_strain_value_limit_checkBox.isChecked():
vmax = 0.2
vmin = -0.2
else:
vmax = None
vmin = None
if self.vis_strain_mat_denoise_checkBox.isChecked():
self.strain_mat_type = 'mat_denoised'
else:
self.strain_mat_type = 'mat'
if self.data[self.data_to_show][self.strain_mat_type] is not None:
self.strainmat_to_show = self.data[self.data_to_show][self.strain_mat_type]
# self.matplot = self.sc.axes.pcolor(self.data[self.data_to_show][strain_mat_type], cmap='jet', vmax = vmax, vmin = vmin)
else:
self.strainmat_to_show = self.data['18'][self.strain_mat_type]
# self.matplot = self.sc.axes.pcolor(self.data['18'][strain_mat_type], cmap='jet', vmax = vmax, vmin = vmin)
# raise ValueError('NO MAT')
if self.inverse_strainmat_checkBox.isChecked():
self.strainmat_to_show = np.flip(strainmat_to_show, axis=0)
self.matplot = self.sc.axes.pcolor(self.strainmat_to_show, cmap='jet', vmax = vmax, vmin = vmin)
if self.vis_strain_colorbar_checkBox.isChecked():
self.matplot_colobar.update_normal(mappable=self.matplot)
# elif self.seg_reso == 126 and self.matFullRes is not None:
# self.sc.axes.pcolor(self.matFullRes, cmap='jet', vmax = 0.2, vmin = -0.2)
# if self.vis_strain_colorbar_checkBox.isChecked():
# self.matplot_colobar = self.sc.fig.colorbar(self.matplot, ax=self.sc.fig.axes)
# else:
# self.matplot_colobar.remove()
# print(self.data_to_show['mat'].shape)
# self.sc.axes.set_size_inches(5,1)
# self.sc.fig.set_size_inches(5,1)
# https://stackoverflow.com/questions/14754931/matplotlib-values-under-cursor
numrows, numcols = self.data[self.data_to_show]['mat'].shape
def format_coord(x, y):
col = int(x+0.5)
row = int(y+0.5)
if col>=0 and col<numcols and row>=0 and row<numrows:
z = self.data[self.data_to_show]['mat'][row,col]
return 'x=%1.4f, y=%1.4f, z=%1.4f'%(x, y, z)
else:
return 'x=%1.4f, y=%1.4f'%(x, y)
self.sc.axes.format_coord = format_coord
# # Re-draw control points and tos curve
lines_to_show = []
# line_colors = ['black']
if self.vis_tos_new_checkBox.isChecked():
self.update_plot()
lines_to_show.append({'line': self.tos_curve_line, 'legend': 'new'})
# self.sc.axes.add_artist(self.tos_curve_line)
# self.tos_curve_line.set_label('New')
# self.sc.axes.legend([self.tos_curve_line], ['new'])
# print(self.data_to_show['TOS'].shape)
if self.data[self.data_to_show]['TOS'] is not None and self.vis_tos_loaded_checkBox.isChecked():
tos_loaded_toshow = self.data[self.data_to_show]['TOS'][::-1] if self.show_inversed_tos else self.data[self.data_to_show]['TOS']
self.tos_loaded_line, = self.sc.axes.plot(tos_loaded_toshow / 17 - 0.5 , np.arange(len(self.data[self.data_to_show]['TOS']))+0.5, color='black')
lines_to_show.append({'line':self.tos_loaded_line, 'legend':'loaded GT'})
if self.data[self.data_to_show]['TOS_Jerry'] is not None and self.vis_tos_Jerry_checkBox.isChecked():
tos_Jerry_toshow = self.data[self.data_to_show]['TOS_Jerry'][::-1] if self.show_inversed_tos else self.data[self.data_to_show]['TOS_Jerry']
self.tos_Jerry_line, = self.sc.axes.plot(tos_Jerry_toshow / 17 - 0.5 , np.arange(len(self.data[self.data_to_show]['TOS_Jerry']))+0.5, color='blue')
lines_to_show.append({'line':self.tos_Jerry_line, 'legend':'Jerry'})
if self.vis_tos_otherRes_checkBox.isChecked() and 'tos_from_other_reso' in self.data[self.data_to_show].keys():
tos_otherRes_toshow = self.data[self.data_to_show]['tos_from_other_reso'][::-1] if self.show_inversed_tos else self.data[self.data_to_show]['tos_from_other_reso']
self.tos_otherRes_line, = self.sc.axes.plot(tos_otherRes_toshow / 17 - 0.5 , np.arange(len(self.data[self.data_to_show]['tos_from_other_reso']))+0.5, color='green')
lines_to_show.append({'line':self.tos_otherRes_line, 'legend':'otherRes'})
for line in lines_to_show:
self.sc.axes.add_artist(line['line'])
self.sc.axes.legend([line['line'] for line in lines_to_show], [line['legend'] for line in lines_to_show])
# TOS_linewidth = 7
# Show loaded TOS
"""
if self.data[self.data_to_show]['TOS'] is not None and self.vis_tos_loaded_checkBox.isChecked():
tos_loaded_toshow = self.data[self.data_to_show]['TOS'][::-1] if self.show_inversed_tos else self.data[self.data_to_show]['TOS']
tos_Jerry_toshow = self.data[self.data_to_show]['TOS_Jerry'][::-1] if self.show_inversed_tos else self.data[self.data_to_show]['TOS_Jerry']
self.tos_loaded_line, = self.sc.axes.plot(tos_loaded_toshow / 17 - 0.5 , np.arange(len(self.data[self.data_to_show]['TOS']))+0.5)
self.tos_Jerry_line, = self.sc.axes.plot(tos_Jerry_toshow / 17 - 0.5 , np.arange(len(self.data[self.data_to_show]['TOS_Jerry']))+0.5)
# print(len(tos_loaded_toshow / 17 - 0.5), len(np.arange(len(self.data_to_show['TOS']))+0.5))
# print(self.sc.axes)
self.sc.axes.add_artist(self.tos_loaded_line)
self.sc.axes.legend([self.tos_curve_line, self.tos_loaded_line, self.tos_Jerry_line], ['new', 'loaded', 'Jerry'])
# self.TOS_loaded_Label.setText('TOS(L): ' + ' '.join([f'{tos:.2f} ' for tos in self.data_to_show['TOS']]))
# self.tos_loaded_line.set_label('Loaded')
#self.sc.axes.legend()
# Show TOS interpolated / subsampled from the other resolution
if self.vis_tos_otherRes_checkBox.isChecked() and 'tos_from_other_reso' in self.data[self.data_to_show].keys():
tos_otherRes_toshow = self.data[self.data_to_show]['tos_from_other_reso'][::-1] if self.show_inversed_tos else self.data[self.data_to_show]['tos_from_other_reso']
self.tos_otherRes_line, = self.sc.axes.plot(tos_otherRes_toshow / 17 - 0.5 , np.arange(len(self.data[self.data_to_show]['tos_from_other_reso']))+0.5, color='green')
self.sc.axes.add_artist(self.tos_otherRes_line)
if self.data[self.data_to_show]['TOS'] is not None:
self.sc.axes.legend([self.tos_curve_line, self.tos_loaded_line, self.tos_otherRes_line], ['new', 'loaded', 'otherRes'])
else:
self.sc.axes.legend([self.tos_curve_line, self.tos_otherRes_line], ['new', 'otherRes'])
"""
self.sc.draw()
# Also refresh the
if self.strainCurvesViewer is not None and self.strainCurvesViewer.isVisible():
self.strainCurvesViewer.refresh(self.strainmat_to_show)
def saveFileDialog(self, fileType, directory):
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
export_fileName, _ = QFileDialog.getSaveFileName(parent = self,
caption = "Save as",
directory = directory,
filter = f"{fileType};;All Files (*)", options=options)
if export_fileName:
self.export_fileName = export_fileName
else:
self.export_fileName = None
def export_TOS_mat(self):
self.saveFileDialog('Matlab File (*.mat)', self.matDirectory + self.export_tos_mat_fname_LE.text() + '.mat')
if self.export_fileName:
annotator_str = '_' + self.annotator_LE.text() if len(self.annotator_LE.text())>0 else ''
if not self.export_fileName.endswith('.mat'):
self.export_fileName += '.mat'
if self.export_tos_mat_tos_only_checkBox.isChecked():
tos_data = {'TOS': self.data['18']['TOS'], 'TOSInterploated':self.data['fullRes']['TOS']}
for data_name in self.data.keys():
tos_data['TOS' + data_name + annotator_str] = np.flip(self.data[data_name]['TOSNew'])
sio.savemat(self.export_fileName, tos_data)
else:
if 'TOSAnalysis' not in self.dataRaw.keys():
no_tosanalysis = True
self.dataRaw['TOSAnalysis'] = {}
else:
no_tosanalysis = False
for data_name in self.data.keys():
if no_tosanalysis:
# exec("self.dataRaw['TOSAnalysis'].TOS" + data_name + annotator_str + "=self.data[data_name]['TOSNew']")
# print(self.data[data_name]['TOSNew'].shape)
self.dataRaw['TOSAnalysis']['TOS' + data_name + annotator_str] = np.flip(self.data[data_name]['TOSNew'])
else:
exec("self.dataRaw['TOSAnalysis'].TOS" + data_name + annotator_str + "=np.flip(self.data[data_name]['TOSNew'])")
# Remove functions in SequenceInfo
seq_rows, seq_cols = self.dataRaw['SequenceInfo'].shape
for seq_row_idx in range(seq_rows):
for seq_col_idx in range(seq_cols):
self.dataRaw['SequenceInfo'][seq_row_idx][seq_col_idx].tform = ''
# Save full resolution strain matrix if needed
if self.data['fullRes']['save']:
self.dataRaw['StrainInfo'].CCmid = self.data['fullRes']['mat']
# exec("self.dataRaw['TOSAnalysis'].TOS" + data_name + annotator_str + "=np.flip(self.data[data_name]['TOSNew'])")
sio.savemat(self.export_fileName, self.dataRaw, long_field_names = True)
# self.dataRaw['TOSAnalysis']
# saveTOS2Mat(self.TOS, self.export_fileName)
def export_TOS_img(self):
self.saveFileDialog('PNG Files (*.png)', self.matDirectory + self.export_tos_img_fname_LE.text() + '.png')
if self.export_fileName:
if not self.export_fileName.endswith('.png'):
self.export_fileName += '.png'
self.sc.fig.savefig(self.export_fileName, bbox_inches='tight')
def export_TOS_img_2clipboard(self):
# https://stackoverflow.com/questions/31607458/how-to-add-clipboard-support-to-matplotlib-figures
buf = io.BytesIO()
self.sc.fig.savefig(buf, bbox_inches='tight')
QApplication.clipboard().setImage(QImage.fromData(buf.getvalue()))
buf.close()
# self.saveFileDialog('PNG Files (*.png)', self.matDirectory + self.export_tos_img_fname_LE.text() + '.png')
# if self.export_fileName:
# if not self.export_fileName.endswith('.png'):
# self.export_fileName += '.png'
# self.sc.fig.savefig(self.export_fileName, bbox_inches='tight')
# def export_TOS_18_2_clipboard(self):
# # https://stackoverflow.com/questions/31607458/how-to-add-clipboard-support-to-matplotlib-figures
# buf = io.BytesIO()
# self.sc.fig.savefig(buf, bbox_inches='tight')
# QApplication.clipboard().setImage(QImage.fromData(buf.getvalue()))
# buf.close()
def initUI(self):
box_team = QHBoxLayout()
lb_team = QLabel("팀명: ", self)
self.cb_team = QComboBox(self)
self.cb_team.addItem("ALL")
self.cb_team.addItems(
self.util.getItems(
self.util.queryExecutor(
"SELECT DISTINCT team_name FROM team")))
box_team.addWidget(lb_team)
box_team.addWidget(self.cb_team)
box_position = QHBoxLayout()
lb_position = QLabel("포지션: ", self)
self.cb_position = QComboBox(self)
self.cb_position.addItem("ALL")
self.cb_position.addItems(
self.util.getItems(
self.util.queryExecutor(
"SELECT DISTINCT position FROM player"), "미정"))
box_position.addWidget(lb_position)
box_position.addWidget(self.cb_position)
box_nation = QHBoxLayout()
lb_nation = QLabel("출신국: ", self)
self.cb_nation = QComboBox(self)
self.cb_nation.addItem("ALL")
self.cb_nation.addItems(
self.util.getItems(
self.util.queryExecutor("SELECT DISTINCT nation FROM player"),
"대한민국"))
box_nation.addWidget(lb_nation)
box_nation.addWidget(self.cb_nation)
box_height = QHBoxLayout()
lb_height = QLabel("키: ", self)
self.le_height = QLineEdit(self)
# self.le_height.setValidator(QIntValidator(self))
bg_height = QButtonGroup(self)
self.rb_height_ge = QRadioButton("이상", self)
self.rb_height_le = QRadioButton("이하", self)
bg_height.addButton(self.rb_height_ge)
bg_height.addButton(self.rb_height_le)
box_height.addWidget(lb_height)
box_height.addWidget(self.le_height)
box_height.addWidget(self.rb_height_ge)
box_height.addWidget(self.rb_height_le)
box_weight = QHBoxLayout()
lb_weight = QLabel("몸무게: ", self)
self.le_weight = QLineEdit(self)
# self.le_weight.setValidator(QIntValidator(self))
bg_weight = QButtonGroup(self)
self.rb_weight_ge = QRadioButton("이상", self)
self.rb_weight_le = QRadioButton("이하", self)
bg_weight.addButton(self.rb_weight_ge)
bg_weight.addButton(self.rb_weight_le)
box_weight.addWidget(lb_weight)
box_weight.addWidget(self.le_weight)
box_weight.addWidget(self.rb_weight_ge)
box_weight.addWidget(self.rb_weight_le)
box_action = QVBoxLayout()
pb_init = QPushButton("초기화", self)
pb_init.clicked.connect(self.init_form)
pb_search = QPushButton("검색", self)
pb_search.clicked.connect(self.player_search)
box_action.addWidget(pb_init)
box_action.addWidget(pb_search)
self.tb_result = QTableWidget(self)
box_save = QHBoxLayout()
self.rb_csv = QRadioButton("CSV", self)
self.rb_json = QRadioButton("JSON", self)
self.rb_xml = QRadioButton("XML", self)
pb_save = QPushButton("저장", self)
pb_save.clicked.connect(self.write_result)
box_save.addWidget(self.rb_csv)
box_save.addWidget(self.rb_json)
box_save.addWidget(self.rb_xml)
box_save.addWidget(pb_save)
# Set layout
box_main = QVBoxLayout()
group_search = QGroupBox("선수 검색")
box_search = QHBoxLayout()
box_input = QVBoxLayout()
box_input_1 = QHBoxLayout()
box_input_1.addLayout(box_team)
box_input_1.addStretch(1)
box_input_1.addLayout(box_position)
box_input_1.addStretch(1)
box_input_1.addLayout(box_nation)
box_input_2 = QHBoxLayout()
box_input_2.addLayout(box_height)
box_input_2.addStretch(1)
box_input_2.addLayout(box_weight)
box_input.addLayout(box_input_1)
box_input.addLayout(box_input_2)
box_search.addLayout(box_input)
box_search.addSpacing(50)
box_search.addLayout(box_action)
group_search.setLayout(box_search)
group_save = QGroupBox("저장")
group_save.setLayout(box_save)
box_main.addWidget(group_search)
box_main.addWidget(self.tb_result)
box_main.addWidget(group_save)
self.setLayout(box_main)
self.setWindowTitle("20171584 김남재")
self.show()
class ExportPanel(Panel):
FIELDS = []
PERSISTENT_NAME = 'exportPanel'
def __init__(self, model, mainwindow):
Panel.__init__(self, mainwindow)
self.setAttribute(Qt.WA_DeleteOnClose)
self.mainwindow = mainwindow
self._setupUi()
self.model = model
self.accountTable = ExportAccountTable(model=self.model.account_table, view=self.tableView)
self.exportTypeButtons.buttonClicked[int].connect(self.exportTypeSelected)
self.exportFormatButtons.buttonClicked[int].connect(self.exportFormatSelected)
self.buttonBox.rejected.connect(self.reject)
self.exportButton.clicked.connect(self.exportButtonClicked)
def _setupUi(self):
self.setWindowTitle(tr("Export Options"))
self.mainLayout = QVBoxLayout(self)
self.label1 = QLabel(tr("Which accounts do you want to export?"), self)
self.mainLayout.addWidget(self.label1)
self.exportTypeButtons = QButtonGroup(self)
self.exportAllButton = QRadioButton(tr("All"), self)
self.mainLayout.addWidget(self.exportAllButton)
self.exportTypeButtons.addButton(self.exportAllButton, ExportType.All)
self.exportAllButton.setChecked(True)
self.exportSelectedButton = QRadioButton(tr("Selected"), self)
self.mainLayout.addWidget(self.exportSelectedButton)
self.exportTypeButtons.addButton(self.exportSelectedButton, ExportType.Selected)
self.tableView = QTableView(self)
self.tableView.setSelectionMode(QAbstractItemView.SingleSelection)
self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tableView.verticalHeader().setVisible(False)
self.tableView.verticalHeader().setDefaultSectionSize(18)
self.mainLayout.addWidget(self.tableView)
self.label2 = QLabel(tr("Export format:"), self)
self.mainLayout.addWidget(self.label2)
self.exportFormatButtons = QButtonGroup(self)
self.exportAsQIFButton = QRadioButton("QIF", self)
self.mainLayout.addWidget(self.exportAsQIFButton)
self.exportFormatButtons.addButton(self.exportAsQIFButton, ExportFormat.QIF)
self.exportAsQIFButton.setChecked(True)
self.exportAsCSVButton = QRadioButton("CSV", self)
self.mainLayout.addWidget(self.exportAsCSVButton)
self.exportFormatButtons.addButton(self.exportAsCSVButton, ExportFormat.CSV)
self.label3 = QLabel(tr("Export scope:"))
self.mainLayout.addWidget(self.label3)
self.dateRangeOnlyCheckbox = QCheckBox(tr("Current date range only"))
self.mainLayout.addWidget(self.dateRangeOnlyCheckbox)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
self.exportButton = self.buttonBox.addButton(tr("Export"), QDialogButtonBox.ActionRole)
self.mainLayout.addWidget(self.buttonBox)
#--- Overrides
def _loadFields(self):
self.exportAllButton.setChecked(self.model.export_all)
self.exportAsQIFButton.setChecked(self.model.export_format == ExportFormat.QIF)
self.dateRangeOnlyCheckbox.setChecked(self.model.current_daterange_only)
def _saveFields(self):
self.model.current_daterange_only = self.dateRangeOnlyCheckbox.isChecked()
#--- Event Handlers
def exportButtonClicked(self):
title = tr("Export")
fileext = 'qif' if self.model.export_format == ExportFormat.QIF else 'csv'
filters = tr("{0} Files (*.{1})").format(fileext.upper(), fileext)
filename = 'export.{0}'.format(fileext)
docpath = str(QFileDialog.getSaveFileName(self.mainwindow, title, filename, filters))
if docpath:
self.model.export_path = docpath
self.accept()
def exportTypeSelected(self, typeId):
self.model.export_all = typeId == ExportType.All
def exportFormatSelected(self, typeId):
self.model.export_format = typeId
#--- model --> view
def set_table_enabled(self, enabled):
self.tableView.setEnabled(enabled)
def set_export_button_enabled(self, enabled):
self.exportButton.setEnabled(enabled)
def __init__(self, parent):
super().__init__(parent)
self.setAcceptDrops(True)
self.parent_widget = parent
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.MinimumExpanding)
self._widget_layout = QHBoxLayout(self)
# widget stuff
self._d_widget = QWidget(self)
self._d_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.MinimumExpanding)
self._widget_layout.addWidget(self._d_widget)
self.main_layout = QVBoxLayout(self._d_widget)
self.main_layout.setSpacing(0)
self.main_layout.setContentsMargins(0,0,0,0)
self.arrow_handle = misc.ArrowHandle(self)
self.arrow_handle.CLICKED.connect(self.slide)
self._widget_layout.addWidget(self.arrow_handle)
self.setContentsMargins(0,0,-self.arrow_handle.width(),0)
self.show_all_galleries_btn = QPushButton("Show all galleries")
self.show_all_galleries_btn.clicked.connect(lambda:parent.manga_list_view.sort_model.set_gallery_list())
self.show_all_galleries_btn.clicked.connect(self.show_all_galleries_btn.hide)
self.show_all_galleries_btn.setIcon(app_constants.CROSS_ICON_WH)
self.show_all_galleries_btn.hide()
self.main_layout.addWidget(self.show_all_galleries_btn)
self.main_buttons_layout = QHBoxLayout()
self.main_layout.addLayout(self.main_buttons_layout)
# buttons
bgroup = QButtonGroup(self)
bgroup.setExclusive(True)
self.lists_btn = QPushButton("")
self.lists_btn.setIcon(app_constants.G_LISTS_ICON_WH)
self.lists_btn.setCheckable(True)
bgroup.addButton(self.lists_btn)
self.artist_btn = QPushButton("")
self.artist_btn.setIcon(app_constants.ARTISTS_ICON)
self.artist_btn.setCheckable(True)
bgroup.addButton(self.artist_btn)
self.ns_tags_btn = QPushButton("")
self.ns_tags_btn.setIcon(app_constants.NSTAGS_ICON)
self.ns_tags_btn.setCheckable(True)
bgroup.addButton(self.ns_tags_btn)
self.lists_btn.setChecked(True)
self.main_buttons_layout.addWidget(self.lists_btn)
self.main_buttons_layout.addWidget(self.artist_btn)
self.main_buttons_layout.addWidget(self.ns_tags_btn)
# buttons contents
self.stacked_layout = QStackedLayout()
self.main_layout.addLayout(self.stacked_layout)
# lists
gallery_lists_dummy = QWidget(self)
self.lists = GalleryLists(self)
create_new_list_btn = QPushButton()
create_new_list_btn.setIcon(QIcon(app_constants.PLUS_ICON))
create_new_list_btn.setIconSize(QSize(15, 15))
create_new_list_btn.clicked.connect(lambda: self.lists.create_new_list())
create_new_list_btn.adjustSize()
create_new_list_btn.setFixedSize(create_new_list_btn.width(), create_new_list_btn.height())
create_new_list_btn.setToolTip("Create a new list!")
lists_l = QVBoxLayout(gallery_lists_dummy)
lists_l.setContentsMargins(0,0,0,0)
lists_l.setSpacing(0)
lists_l.addWidget(self.lists)
lists_l.addWidget(create_new_list_btn)
lists_index = self.stacked_layout.addWidget(gallery_lists_dummy)
self.lists.GALLERY_LIST_CLICKED.connect(parent.manga_list_view.sort_model.set_gallery_list)
self.lists.GALLERY_LIST_CLICKED.connect(self.show_all_galleries_btn.show)
self.lists.GALLERY_LIST_REMOVED.connect(self.show_all_galleries_btn.click)
self.lists_btn.clicked.connect(lambda:self.stacked_layout.setCurrentIndex(lists_index))
self.show_all_galleries_btn.clicked.connect(self.lists.clearSelection)
self.show_all_galleries_btn.clicked.connect(self.lists._reset_selected)
# artists
self.artists_list = GalleryArtistsList(parent.manga_list_view.gallery_model, self)
self.artists_list.artist_clicked.connect(lambda a: parent.search('artist:"{}"'.format(a)))
artists_list_index = self.stacked_layout.addWidget(self.artists_list)
self.artist_btn.clicked.connect(lambda:self.stacked_layout.setCurrentIndex(artists_list_index))
#self.lists.GALLERY_LIST_CLICKED.connect(self.artists_list.set_current_glist)
self.show_all_galleries_btn.clicked.connect(self.artists_list.clearSelection)
#self.show_all_galleries_btn.clicked.connect(lambda:self.artists_list.set_current_glist())
# ns_tags
self.tags_tree = TagsTreeView(self)
self.tags_tree.TAG_SEARCH.connect(parent.search)
self.tags_tree.NEW_LIST.connect(self.lists.create_new_list)
self.tags_tree.setHeaderHidden(True)
self.show_all_galleries_btn.clicked.connect(self.tags_tree.clearSelection)
self.tags_layout = QVBoxLayout(self.tags_tree)
ns_tags_index = self.stacked_layout.addWidget(self.tags_tree)
self.ns_tags_btn.clicked.connect(lambda:self.stacked_layout.setCurrentIndex(ns_tags_index))
self.slide_animation = misc.create_animation(self, "maximumSize")
self.slide_animation.stateChanged.connect(self._slide_hide)
self.slide_animation.setEasingCurve(QEasingCurve.InOutQuad)
def _getSchedulingTab(self):
modeLabel = QLabel('Scheduling Mode')
manualButton = QRadioButton('Manual')
self.prioButton = QRadioButton('Priorities')
soonLabel = QLabel('Soon Button')
laterLabel = QLabel('Later Button')
extractLabel = QLabel('Extracts')
self.soonPercentButton = QRadioButton('Percent')
soonPositionButton = QRadioButton('Position')
self.laterPercentButton = QRadioButton('Percent')
laterPositionButton = QRadioButton('Position')
self.extractPercentButton = QRadioButton('Percent')
extractPositionButton = QRadioButton('Position')
self.soonRandomCheckBox = QCheckBox('Randomize')
self.laterRandomCheckBox = QCheckBox('Randomize')
self.extractRandomCheckBox = QCheckBox('Randomize')
self.soonValueEditBox = QLineEdit()
self.soonValueEditBox.setFixedWidth(100)
self.laterValueEditBox = QLineEdit()
self.laterValueEditBox.setFixedWidth(100)
self.extractValueEditBox = QLineEdit()
self.extractValueEditBox.setFixedWidth(100)
if self.settings['prioEnabled']:
self.prioButton.setChecked(True)
else:
manualButton.setChecked(True)
if self.settings['soonMethod'] == 'percent':
self.soonPercentButton.setChecked(True)
else:
soonPositionButton.setChecked(True)
if self.settings['laterMethod'] == 'percent':
self.laterPercentButton.setChecked(True)
else:
laterPositionButton.setChecked(True)
if self.settings['extractMethod'] == 'percent':
self.extractPercentButton.setChecked(True)
else:
extractPositionButton.setChecked(True)
if self.settings['soonRandom']:
self.soonRandomCheckBox.setChecked(True)
if self.settings['laterRandom']:
self.laterRandomCheckBox.setChecked(True)
if self.settings['extractRandom']:
self.extractRandomCheckBox.setChecked(True)
self.soonValueEditBox.setText(str(self.settings['soonValue']))
self.laterValueEditBox.setText(str(self.settings['laterValue']))
self.extractValueEditBox.setText(str(self.settings['extractValue']))
formatLabel = QLabel('Organizer Format')
self.organizerFormatEditBox = QLineEdit()
self.organizerFormatEditBox.setFixedWidth(400)
self.organizerFormatEditBox.setText(
self.settings['organizerFormat'].replace('\t', r'\t'))
font = QFont('Lucida Sans Typewriter')
font.setStyleHint(QFont.Monospace)
self.organizerFormatEditBox.setFont(font)
modeLayout = QHBoxLayout()
modeLayout.addWidget(modeLabel)
modeLayout.addStretch()
modeLayout.addWidget(manualButton)
modeLayout.addWidget(self.prioButton)
soonLayout = QHBoxLayout()
soonLayout.addWidget(soonLabel)
soonLayout.addStretch()
soonLayout.addWidget(self.soonValueEditBox)
soonLayout.addWidget(self.soonPercentButton)
soonLayout.addWidget(soonPositionButton)
soonLayout.addWidget(self.soonRandomCheckBox)
laterLayout = QHBoxLayout()
laterLayout.addWidget(laterLabel)
laterLayout.addStretch()
laterLayout.addWidget(self.laterValueEditBox)
laterLayout.addWidget(self.laterPercentButton)
laterLayout.addWidget(laterPositionButton)
laterLayout.addWidget(self.laterRandomCheckBox)
extractLayout = QHBoxLayout()
extractLayout.addWidget(extractLabel)
extractLayout.addStretch()
extractLayout.addWidget(self.extractValueEditBox)
extractLayout.addWidget(self.extractPercentButton)
extractLayout.addWidget(extractPositionButton)
extractLayout.addWidget(self.extractRandomCheckBox)
modeButtonGroup = QButtonGroup(modeLayout)
modeButtonGroup.addButton(manualButton)
modeButtonGroup.addButton(self.prioButton)
soonButtonGroup = QButtonGroup(soonLayout)
soonButtonGroup.addButton(self.soonPercentButton)
soonButtonGroup.addButton(soonPositionButton)
laterButtonGroup = QButtonGroup(laterLayout)
laterButtonGroup.addButton(self.laterPercentButton)
laterButtonGroup.addButton(laterPositionButton)
extractButtonGroup = QButtonGroup(extractLayout)
extractButtonGroup.addButton(self.extractPercentButton)
extractButtonGroup.addButton(extractPositionButton)
formatLayout = QHBoxLayout()
formatLayout.addWidget(formatLabel)
formatLayout.addWidget(self.organizerFormatEditBox)
layout = QVBoxLayout()
layout.addLayout(modeLayout)
layout.addLayout(soonLayout)
layout.addLayout(laterLayout)
layout.addLayout(extractLayout)
layout.addLayout(formatLayout)
layout.addStretch()
tab = QWidget()
tab.setLayout(layout)
return tab
class SelectionW(QGridLayout):
paraChanged = pyqtSignal()
selScheme = pyqtSignal(str)
def __init__(self, hmap):
super(SelectionW, self).__init__()
self.hmap = hmap
self.create_widgets()
self.set_widgets()
self.layout_widgets()
self.create_connections()
def toggle_visibility(self, hide=False):
vis = not self.title.isVisible()
if hide:
vis = False
self.title.setVisible(vis)
self.resetButton.setVisible(vis)
self.bgLabel.setVisible(vis)
self.rgb.setVisible(vis)
self.hsv.setVisible(vis)
self.hsx.setVisible(vis)
self.para1Label.setVisible(vis)
self.para2Label.setVisible(vis)
self.para3Label.setVisible(vis)
self.min1.setVisible(vis)
self.del1.setVisible(vis)
self.max1.setVisible(vis)
self.min1Label.setVisible(vis)
self.del1Label.setVisible(vis)
self.max1Label.setVisible(vis)
self.min2.setVisible(vis)
self.del2.setVisible(vis)
self.max2.setVisible(vis)
self.min2Label.setVisible(vis)
self.del2Label.setVisible(vis)
self.max2Label.setVisible(vis)
self.min3.setVisible(vis)
self.del3.setVisible(vis)
self.max3.setVisible(vis)
self.min3Label.setVisible(vis)
self.del3Label.setVisible(vis)
self.max3Label.setVisible(vis)
def create_widgets(self):
self.title = QLabel("* Selection *")
color_label(self.title, QColor("black"), QColor("white"))
self.resetButton = QPushButton("Reset")
self.bgLabel = QLabel("color scheme")
self.bg = QButtonGroup()
self.rgb = QRadioButton("rgb")
self.hsv = QRadioButton("hsv")
self.hsx = QRadioButton("hs")
self.bg.addButton(self.rgb)
self.bg.addButton(self.hsv)
self.bg.addButton(self.hsx)
self.para1Label = QLabel("Parameter 1 (Red/Hue)")
self.min1 = QSpinBox()
self.del1 = QSpinBox()
self.max1 = QSpinBox()
self.min1Label = QLabel("min")
self.del1Label = QLabel("del")
self.max1Label = QLabel("max")
self.para2Label = QLabel("Parameter 2 (Green/Saturation)")
self.min2 = QSpinBox()
self.del2 = QSpinBox()
self.max2 = QSpinBox()
self.min2Label = QLabel("min")
self.del2Label = QLabel("del")
self.max2Label = QLabel("max")
self.para3Label = QLabel("Parameter 3 (Blue/Value)")
self.min3 = QSpinBox()
self.del3 = QSpinBox()
self.max3 = QSpinBox()
self.min3Label = QLabel("min")
self.del3Label = QLabel("del")
self.max3Label = QLabel("max")
def set_widgets(self):
self.min1.setMinimum(-1)
self.min2.setMinimum(0)
self.min3.setMinimum(0)
self.min1.setMaximum(359)
self.min2.setMaximum(359)
self.min3.setMaximum(359)
self.del1.setMinimum(0)
self.del2.setMinimum(0)
self.del3.setMinimum(0)
self.del1.setMaximum(359)
self.del2.setMaximum(359)
self.del3.setMaximum(359)
self.max1.setMinimum(0)
self.max2.setMinimum(0)
self.max3.setMinimum(0)
self.max1.setMaximum(359)
self.max2.setMaximum(359)
self.max3.setMaximum(359)
for w in (self.min1Label, self.del1Label, self.max1Label,
self.min2Label, self.del2Label, self.max2Label,
self.min3Label, self.del3Label, self.max3Label):
w.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.reset()
def layout_widgets(self):
self.addWidget(self.title, 0, 0, 1, 7)
self.addWidget(self.resetButton, 0, 7)
self.addWidget(self.bgLabel, 1, 0, 1, 2)
for x in range(1, 4):
self.addWidget(self.__dict__["para" + str(x) + "Label"], x + 1, 0)
self.addWidget(self.__dict__["min" + str(x) + "Label"], x + 1, 1)
self.addWidget(self.__dict__["min" + str(x)], x + 1, 2)
self.addWidget(self.__dict__["del" + str(x) + "Label"], x + 1, 3)
self.addWidget(self.__dict__["del" + str(x)], x + 1, 4)
self.addWidget(self.__dict__["max" + str(x) + "Label"], x + 1, 5)
self.addWidget(self.__dict__["max" + str(x)], x + 1, 6)
def create_connections(self):
self.rgb.toggled.connect(self.rgbtoggle)
self.hsv.toggled.connect(self.rgbtoggle)
self.hsx.toggled.connect(self.rgbtoggle)
self.resetButton.clicked.connect(self.reset)
for x in range(1, 4):
for y in ("min", "del", "max"):
self.__dict__[y + str(x)].valueChanged.connect(
self.paraChanged)
def reset(self):
self.min1.setValue(0)
self.min2.setValue(15)
self.min3.setValue(0)
self.del1.setValue(6)
self.del2.setValue(15)
self.del3.setValue(0)
self.max1.setValue(359)
self.max2.setValue(359)
self.max3.setValue(359)
self.hsx.setChecked(True)
self.addWidget(self.rgb, 1, 2)
self.addWidget(self.hsv, 1, 3)
self.addWidget(self.hsx, 1, 4)
def rgbtoggle(self):
text = self.get_color_scheme()
self.selScheme.emit(text)
def get_color_scheme(self):
return self.bg.checkedButton().text()
def get_para(self, n):
if n == 1:
return self.min1.value(), self.del1.value(), self.max1.value()
elif n == 2:
return self.min2.value(), self.del2.value(), self.max2.value()
elif n == 3:
return self.min3.value(), self.del3.value(), self.max3.value()
else:
raise ValueError(n)
def get_dpara(self):
return {i: self.get_para(i) for i in range(1, 4)}
def set_dpara(self, d):
for i, val in d.items():
assert i in range(1, 4)
self.set_para(i, val)
def set_para(self, i, val):
s = str(i)
self.__dict__["min" + s].setValue(val[0])
self.__dict__["del" + s].setValue(val[1])
self.__dict__["max" + s].setValue(val[2])
class DataCheck(Content):
def __init__(self, parent=None, button_func=None, params=None):
super().__init__(parent, 'Data check', params)
self.button_func = button_func
path = os.path.abspath(os.path.dirname(__file__)) + '/static/'
# nr = min(5, data.shape[0])
nr = len(self.params.data5)
if params.lang == 'jp':
text = ('データの読み込み結果（先頭{n}行）を以下に示します．\n'
'データを正しく読み込めていることを確認してください．'.format(n=nr))
self.set_paragraph(
'データ読み込み結果の確認', text=text)
else:
text = ('First {n} rows of your data are shown below.\n'
'Confirm that the data was read correctly.'.format(n=nr))
self.set_paragraph(
'Check data', text=text)
table = NonScrollTable(self.inner)
table.setRowCount(nr)
table.setColumnCount(len(self.params.columns))
table.setHorizontalHeaderLabels(self.params.columns)
for r in range(nr):
for c in range(len(self.params.columns)):
item = QTableWidgetItem(str(self.params.data5.iat[r, c]))
item.setFlags(Qt.ItemIsEnabled)
table.setItem(r, c, item)
table.setNonScroll()
self.vbox.addWidget(table)
# Text for type checking and objective variable setting
path1 = path + 'categorical'
text = self.get_text(path1)
if self.params.lang == 'en':
self.set_paragraph(
'Check type of variables and set objective variable',
text=text)
else:
self.set_paragraph('変数タイプの確認と目的変数の設定', text=text)
# htable = QTableWidget(self.inner)
htable = NonScrollTable(self.inner)
htable.setRowCount(len(self.params.columns))
htable.setColumnCount(4)
htable.setHorizontalHeaderLabels(
['columns', 'categorical', 'numerical', 'target'])
self.lst_cat = []
self.lst_num = []
self.lst_obj = []
self.obj_group = QButtonGroup(self.inner)
for c in range(len(self.params.columns)):
# col 1
item = QTableWidgetItem(self.params.columns[c])
item.setFlags(Qt.ItemIsEnabled)
htable.setItem(c, 0, item)
group = QButtonGroup(self.inner)
# col 2
htable.setCellWidget(
c, 1,
self.__make_cell(c, 'cat', self.params.col_types[c],
self.params.col_types_def[c]))
group.addButton(self.lst_cat[-1])
# col 3
htable.setCellWidget(
c, 2,
self.__make_cell(c, 'num', self.params.col_types[c],
self.params.col_types_def[c]))
group.addButton(self.lst_num[-1])
# col 4
htable.setCellWidget(
c, 3,
self.__make_cell(c, 'obj', self.params.col_types[c],
self.params.col_types_def[c]))
self.obj_group.addButton(self.lst_obj[-1])
self.obj_group.setId(self.lst_obj[-1], c)
htable.setNonScroll()
self.vbox.addWidget(htable)
if self.params.lang == 'jp':
self.txt_cnf = ('<font color="red">目的変数を１つ選択し，'
'targetの列にチェックをいれてください。')
if self.params.task.lower() == 'classification':
self.txt_cnf += '<br>目的変数はカテゴリ変数である必要があります。</font>'
else:
self.txt_cnf += '<br>目的変数は量的変数である必要があります。</font>'
else:
self.txt_cnf = ('<font color="red">Select one variable as target variable,'
'then set the column of "target" of the variable checked.')
if self.params.task.lower() == 'classification':
self.txt_cnf += '<br>Target variable must be a categorical variable.</font>'
else:
self.txt_cnf += '<br>Target variable must be a numerical variable.</font>'
self.lbl_cnf = QLabel(self.txt_cnf, self.inner)
self.vbox.addWidget(self.lbl_cnf)
self.vbox.addStretch(1)
self.btn = QPushButton('Next', self.inner)
self.btn.setStyleSheet('QPushButton{font: bold; font-size: 15pt; background-color: white;};')
if self.params.lang == 'en':
self.btn.clicked.connect(lambda: self.button_func('Overfitting'))
else:
self.btn.clicked.connect(lambda: self.button_func('過学習'))
if self.obj_group.checkedButton() is None:
self.btn.setEnabled(False)
else:
self.btn.setEnabled(True)
self.vbox.addWidget(self.btn)
def __make_cell(self, c, name, col_type, col_type_def):
cell = QWidget(self.inner)
rbtn = QRadioButton('', cell)
rbtn.toggled.connect(lambda: self.rbtn_clicked(name + '_' + str(c)))
hbl = QHBoxLayout(cell)
hbl.addWidget(rbtn)
hbl.setContentsMargins(0, 0, 0, 0)
hbl.setAlignment(Qt.AlignCenter)
cell.setLayout(hbl)
if name == 'cat':
if col_type == 'object':
rbtn.setChecked(True)
self.lst_cat.append(rbtn)
elif name == 'num':
if col_type != 'object':
rbtn.setChecked(True)
if col_type_def == 'object':
rbtn.setEnabled(False)
self.lst_num.append(rbtn)
elif name == 'obj':
if col_type == 'object' and self.params.task == 'Regression':
rbtn.setEnabled(False)
elif col_type != 'object' and self.params.task == 'Classification':
rbtn.setEnabled(False)
if self.params.columns[c] == self.params.objective:
rbtn.setChecked(True)
self.lst_obj.append(rbtn)
return cell
def rbtn_clicked(self, text):
name, idx = text.split('_')
idx = int(idx)
if len(self.lst_obj) <= idx:
return
if self.lst_num[idx].isChecked():
if self.params.task == 'Classification':
self.obj_group.setExclusive(False)
self.lst_obj[idx].setChecked(False)
self.obj_group.setExclusive(True)
self.lst_obj[idx].setEnabled(False)
elif self.params.task == 'Regression':
self.lst_obj[idx].setEnabled(True)
self.params.col_types[idx] = self.params.col_types_def[idx]
elif self.lst_cat[idx].isChecked():
if self.params.task == 'Classification':
self.lst_obj[idx].setEnabled(True)
elif self.params.task == 'Regression':
self.obj_group.setExclusive(False)
self.lst_obj[idx].setChecked(False)
self.obj_group.setExclusive(True)
self.lst_obj[idx].setEnabled(False)
self.params.col_types[idx] = 'object'
if self.obj_group.checkedButton() is None:
self.params.objective = None
self.lbl_cnf.setText(self.txt_cnf)
self.btn.setEnabled(False)
else:
self.params.objective =\
self.params.columns[self.obj_group.checkedId()]
self.lbl_cnf.setText('<br>')
self.btn.setEnabled(True)
self.params.col_types_changed = True
class HelpViewersPage(ConfigurationPageBase, Ui_HelpViewersPage):
"""
Class implementing the Help Viewers configuration page.
"""
def __init__(self):
"""
Constructor
"""
super(HelpViewersPage, self).__init__()
self.setupUi(self)
self.setObjectName("HelpViewersPage")
self.customViewerSelectionButton.setIcon(
UI.PixmapCache.getIcon("open.png"))
self.helpViewerGroup = QButtonGroup()
self.helpViewerGroup.addButton(self.helpBrowserButton)
self.helpViewerGroup.addButton(self.qtAssistantButton)
self.helpViewerGroup.addButton(self.webBrowserButton)
self.helpViewerGroup.addButton(self.customViewerButton)
self.customViewerCompleter = E5FileCompleter(self.customViewerEdit)
# set initial values
hvId = Preferences.getHelp("HelpViewerType")
if hvId == 1:
self.helpBrowserButton.setChecked(True)
elif hvId == 2:
self.qtAssistantButton.setChecked(True)
elif hvId == 3:
self.webBrowserButton.setChecked(True)
else:
self.customViewerButton.setChecked(True)
self.customViewerEdit.setText(
Preferences.getHelp("CustomViewer"))
def save(self):
"""
Public slot to save the Help Viewers configuration.
"""
if self.helpBrowserButton.isChecked():
hvId = 1
elif self.qtAssistantButton.isChecked():
hvId = 2
elif self.webBrowserButton.isChecked():
hvId = 3
elif self.customViewerButton.isChecked():
hvId = 4
Preferences.setHelp("HelpViewerType", hvId)
Preferences.setHelp(
"CustomViewer",
self.customViewerEdit.text())
@pyqtSlot()
def on_customViewerSelectionButton_clicked(self):
"""
Private slot to handle the custom viewer selection.
"""
file = E5FileDialog.getOpenFileName(
self,
self.tr("Select Custom Viewer"),
self.customViewerEdit.text(),
"")
if file:
self.customViewerEdit.setText(Utilities.toNativeSeparators(file))
@pyqtSlot()
def on_webbrowserButton_clicked(self):
"""
Private slot to handle the Web browser selection.
"""
file = E5FileDialog.getOpenFileName(
self,
self.tr("Select Web-Browser"),
self.webbrowserEdit.text(),
"")
if file:
self.webbrowserEdit.setText(Utilities.toNativeSeparators(file))
@pyqtSlot()
def on_pdfviewerButton_clicked(self):
"""
Private slot to handle the PDF viewer selection.
"""
file = E5FileDialog.getOpenFileName(
self,
self.tr("Select PDF-Viewer"),
self.pdfviewerEdit.text(),
"")
if file:
self.pdfviewerEdit.setText(Utilities.toNativeSeparators(file))
@pyqtSlot()
def on_chmviewerButton_clicked(self):
"""
Private slot to handle the CHM viewer selection.
"""
file = E5FileDialog.getOpenFileName(
self,
self.tr("Select CHM-Viewer"),
self.chmviewerEdit.text(),
"")
if file:
self.chmviewerEdit.setText(Utilities.toNativeSeparators(file))
def gatherControls(config, ui_mode="file"):
config_inputs = {
'anki_db_path': '',
'anki_db_field_indices': '',
'media_dir_path': '',
'file_or_dir': '',
'input_encoding': ''
}
ui_inputs = {
'file_to_scan':
'''<span><b>File to scan:</b><br>This is the input file which
will be scanned for new words. Note, it is possible to scan
a whole collection of files at once by changing the file_or_dir
property in the config to dir, and then putting the dir path here.</span>''',
'scan_mode':
'''<br><span><b>Mode:</b><br>Choose whether to produce a card for every new words, every new inidividual character, or only new words using new characters</span>''',
'output_path':
'''<br><span><b>Output path:</b><br>Where the resulting .apkg file should be placed
(including the filename.apkg)</span>''',
'tag_for_new_cards':
'''<br><span><b>Imported deck/tag name:</b><br>This string cannot contain
spaces. It will be applied to all new notes as a tag,
and will also be the name of the deck imported.</span>''',
'anki_tags_to_exclude':
'''<br><span><b>Tags to exclude:</b><br>
A comma separated list of tags, these will be excluded from
the de-duping process. That means the scanner will still
consider a word to be new, even if it contains a character
in one of your existing notes tagged with one of these tags</span>''',
'include_sound':
'''<br><span><b>Include sound files:</b><br>If this is true, the scanner will
download sound files of the word readings and include them as media in the generated notes.</span>'''
}
hidden_cfg = {}
for item in config_inputs:
if item == 'file_or_dir' and ui_mode == 'clipboard':
hidden_cfg[item] = 'clipboard'
else:
hidden_cfg[item] = config['textScanner'][item]['val']
new_words = "All new words"
new_chars = "Individual new characters"
new_char_words = "Only words using new chars"
def interpretRadioBtn(b, input):
input['mode'] = b.mode
controls = []
if ui_mode == 'dev':
label = QLabel()
label.setWordWrap(True)
label_text = '''<br><span><b>Query anki db:</b><br>You can run a sqlite query to probe the anki notes db</span>'''
label.setText(label_text)
query_input = QPlainTextEdit()
controls.append({
"key": "query_db",
"label": label,
"input": query_input
})
else:
for ipt in ui_inputs:
label = QLabel()
label.setWordWrap(True)
label.setText(ui_inputs[ipt])
tryConfig = config['textScanner'].get(ipt)
default = str(
tryConfig['val']) if tryConfig != None else "Uninitialized"
if ipt == 'scan_mode':
b1 = QRadioButton(new_char_words)
b1.mode = 'new_char_words'
b2 = QRadioButton(new_chars)
b2.mode = 'new_chars'
b3 = QRadioButton(new_words)
b3.mode = 'new_words'
if default == 'new_char_words':
b1.setChecked(True)
if default == 'new_chars':
b2.setChecked(True)
if default == 'new_words':
b3.setChecked(True)
radioLayout = QHBoxLayout()
btnGrp = QButtonGroup()
btnGrp.addButton(b1)
btnGrp.addButton(b2)
btnGrp.addButton(b3)
radioLayout.addWidget(b1)
radioLayout.addWidget(b2)
radioLayout.addWidget(b3)
scan_input = {
"mode": default,
"layout": radioLayout,
"btnGrp": btnGrp
}
b1.toggled.connect(lambda: interpretRadioBtn(b1, scan_input))
b2.toggled.connect(lambda: interpretRadioBtn(b2, scan_input))
b3.toggled.connect(lambda: interpretRadioBtn(b3, scan_input))
controls.append({
"key": ipt,
"label": label,
"input": scan_input
})
elif ipt == 'file_to_scan' and ui_mode == 'clipboard':
clipboard_input = QPlainTextEdit()
label.setText("<span><b>Input text:</b></span>")
controls.append({
"key": ipt,
"label": label,
"input": clipboard_input
})
elif ipt == 'include_sound':
sb1 = QRadioButton("True")
sb1.mode = 'true'
sb2 = QRadioButton("False")
sb2.mode = 'false'
if default == 'true':
sb1.setChecked(True)
else:
sb2.setChecked(True)
soundLayout = QHBoxLayout()
btnGrp = QButtonGroup()
btnGrp.addButton(sb1)
btnGrp.addButton(sb2)
soundLayout.addWidget(sb1)
soundLayout.addWidget(sb2)
sound_input = {
"mode": default,
"layout": soundLayout,
"btnGrp": btnGrp
}
sb1.toggled.connect(
lambda: interpretRadioBtn(sb1, sound_input))
sb2.toggled.connect(
lambda: interpretRadioBtn(sb2, sound_input))
controls.append({
"key": ipt,
"label": label,
"input": sound_input
})
else:
input = QLineEdit()
input.setText(default)
controls.append({"key": ipt, "label": label, "input": input})
return controls, hidden_cfg
class MainWindow(QMainWindow):
InsertTextButton = 10
def __init__(self):
super(MainWindow, self).__init__()
self.createActions()
self.createMenus()
self.createToolBox()
self.scene = DiagramScene(self.itemMenu)
self.scene.setSceneRect(QRectF(0, 0, 5000, 5000))
self.scene.itemInserted.connect(self.itemInserted)
self.scene.textInserted.connect(self.textInserted)
self.scene.itemSelected.connect(self.itemSelected)
self.createToolbars()
layout = QHBoxLayout()
layout.addWidget(self.toolBox)
self.view = QGraphicsView(self.scene)
layout.addWidget(self.view)
self.widget = QWidget()
self.widget.setLayout(layout)
self.setCentralWidget(self.widget)
self.setWindowTitle("Diagramscene")
def backgroundButtonGroupClicked(self, button):
buttons = self.backgroundButtonGroup.buttons()
for myButton in buttons:
if myButton != button:
button.setChecked(False)
text = button.text()
if text == "Blue Grid":
self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background1.png')))
elif text == "White Grid":
self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background2.png')))
elif text == "Gray Grid":
self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background3.png')))
else:
self.scene.setBackgroundBrush(QBrush(QPixmap(':/images/background4.png')))
self.scene.update()
self.view.update()
def buttonGroupClicked(self, id):
buttons = self.buttonGroup.buttons()
for button in buttons:
if self.buttonGroup.button(id) != button:
button.setChecked(False)
if id == self.InsertTextButton:
self.scene.setMode(DiagramScene.InsertText)
else:
self.scene.setItemType(id)
self.scene.setMode(DiagramScene.InsertItem)
def deleteItem(self):
for item in self.scene.selectedItems():
if isinstance(item, DiagramItem):
item.removeArrows()
self.scene.removeItem(item)
def pointerGroupClicked(self, i):
self.scene.setMode(self.pointerTypeGroup.checkedId())
def bringToFront(self):
if not self.scene.selectedItems():
return
selectedItem = self.scene.selectedItems()[0]
overlapItems = selectedItem.collidingItems()
zValue = 0
for item in overlapItems:
if (item.zValue() >= zValue and isinstance(item, DiagramItem)):
zValue = item.zValue() + 0.1
selectedItem.setZValue(zValue)
def sendToBack(self):
if not self.scene.selectedItems():
return
selectedItem = self.scene.selectedItems()[0]
overlapItems = selectedItem.collidingItems()
zValue = 0
for item in overlapItems:
if (item.zValue() <= zValue and isinstance(item, DiagramItem)):
zValue = item.zValue() - 0.1
selectedItem.setZValue(zValue)
def itemInserted(self, item):
self.pointerTypeGroup.button(DiagramScene.MoveItem).setChecked(True)
self.scene.setMode(self.pointerTypeGroup.checkedId())
self.buttonGroup.button(item.diagramType).setChecked(False)
def textInserted(self, item):
self.buttonGroup.button(self.InsertTextButton).setChecked(False)
self.scene.setMode(self.pointerTypeGroup.checkedId())
def currentFontChanged(self, font):
self.handleFontChange()
def fontSizeChanged(self, font):
self.handleFontChange()
def sceneScaleChanged(self, scale):
newScale = scale.left(scale.indexOf("%")).toDouble()[0] / 100.0
oldMatrix = self.view.matrix()
self.view.resetMatrix()
self.view.translate(oldMatrix.dx(), oldMatrix.dy())
self.view.scale(newScale, newScale)
def textColorChanged(self):
self.textAction = self.sender()
self.fontColorToolButton.setIcon(
self.createColorToolButtonIcon(':/images/textpointer.png',
QColor(self.textAction.data())))
self.textButtonTriggered()
def itemColorChanged(self):
self.fillAction = self.sender()
self.fillColorToolButton.setIcon(
self.createColorToolButtonIcon( ':/images/floodfill.png',
QColor(self.fillAction.data())))
self.fillButtonTriggered()
def lineColorChanged(self):
self.lineAction = self.sender()
self.lineColorToolButton.setIcon(
self.createColorToolButtonIcon(':/images/linecolor.png',
QColor(self.lineAction.data())))
self.lineButtonTriggered()
def textButtonTriggered(self):
self.scene.setTextColor(QColor(self.textAction.data()))
def fillButtonTriggered(self):
self.scene.setItemColor(QColor(self.fillAction.data()))
def lineButtonTriggered(self):
self.scene.setLineColor(QColor(self.lineAction.data()))
def handleFontChange(self):
font = self.fontCombo.currentFont()
font.setPointSize(self.fontSizeCombo.currentText().toInt()[0])
if self.boldAction.isChecked():
font.setWeight(QFont.Bold)
else:
font.setWeight(QFont.Normal)
font.setItalic(self.italicAction.isChecked())
font.setUnderline(self.underlineAction.isChecked())
self.scene.setFont(font)
def itemSelected(self, item):
font = item.font()
color = item.defaultTextColor()
self.fontCombo.setCurrentFont(font)
self.fontSizeCombo.setEditText(str(font.pointSize()))
self.boldAction.setChecked(font.weight() == QFont.Bold)
self.italicAction.setChecked(font.italic())
self.underlineAction.setChecked(font.underline())
def about(self):
QMessageBox.about(self, "About Diagram Scene",
"The <b>Diagram Scene</b> example shows use of the graphics framework.")
def createToolBox(self):
self.buttonGroup = QButtonGroup()
self.buttonGroup.setExclusive(False)
self.buttonGroup.buttonClicked[int].connect(self.buttonGroupClicked)
layout = QGridLayout()
layout.addWidget(self.createCellWidget("Conditional", DiagramItem.Conditional),
0, 0)
layout.addWidget(self.createCellWidget("Process", DiagramItem.Step), 0,
1)
layout.addWidget(self.createCellWidget("Input/Output", DiagramItem.Io),
1, 0)
textButton = QToolButton()
textButton.setCheckable(True)
self.buttonGroup.addButton(textButton, self.InsertTextButton)
textButton.setIcon(QIcon(QPixmap(':/images/textpointer.png').scaled(30, 30)))
textButton.setIconSize(QSize(50, 50))
textLayout = QGridLayout()
textLayout.addWidget(textButton, 0, 0, Qt.AlignHCenter)
textLayout.addWidget(QLabel("Text"), 1, 0, Qt.AlignCenter)
textWidget = QWidget()
textWidget.setLayout(textLayout)
layout.addWidget(textWidget, 1, 1)
layout.setRowStretch(3, 10)
layout.setColumnStretch(2, 10)
itemWidget = QWidget()
itemWidget.setLayout(layout)
self.backgroundButtonGroup = QButtonGroup()
self.backgroundButtonGroup.buttonClicked.connect(self.backgroundButtonGroupClicked)
backgroundLayout = QGridLayout()
backgroundLayout.addWidget(self.createBackgroundCellWidget("Blue Grid",
':/images/background1.png'), 0, 0)
backgroundLayout.addWidget(self.createBackgroundCellWidget("White Grid",
':/images/background2.png'), 0, 1)
backgroundLayout.addWidget(self.createBackgroundCellWidget("Gray Grid",
':/images/background3.png'), 1, 0)
backgroundLayout.addWidget(self.createBackgroundCellWidget("No Grid",
':/images/background4.png'), 1, 1)
backgroundLayout.setRowStretch(2, 10)
backgroundLayout.setColumnStretch(2, 10)
backgroundWidget = QWidget()
backgroundWidget.setLayout(backgroundLayout)
self.toolBox = QToolBox()
self.toolBox.setSizePolicy(QSizePolicy(QSizePolicy.Maximum, QSizePolicy.Ignored))
self.toolBox.setMinimumWidth(itemWidget.sizeHint().width())
self.toolBox.addItem(itemWidget, "Basic Flowchart Shapes")
self.toolBox.addItem(backgroundWidget, "Backgrounds")
def createActions(self):
self.toFrontAction = QAction(
QIcon(':/images/bringtofront.png'), "Bring to &Front",
self, shortcut="Ctrl+F", statusTip="Bring item to front",
triggered=self.bringToFront)
self.sendBackAction = QAction(
QIcon(':/images/sendtoback.png'), "Send to &Back", self,
shortcut="Ctrl+B", statusTip="Send item to back",
triggered=self.sendToBack)
self.deleteAction = QAction(QIcon(':/images/delete.png'),
"&Delete", self, shortcut="Delete",
statusTip="Delete item from diagram",
triggered=self.deleteItem)
self.exitAction = QAction("E&xit", self, shortcut="Ctrl+X",
statusTip="Quit Scenediagram example", triggered=self.close)
self.boldAction = QAction(QIcon(':/images/bold.png'),
"Bold", self, checkable=True, shortcut="Ctrl+B",
triggered=self.handleFontChange)
self.italicAction = QAction(QIcon(':/images/italic.png'),
"Italic", self, checkable=True, shortcut="Ctrl+I",
triggered=self.handleFontChange)
self.underlineAction = QAction(
QIcon(':/images/underline.png'), "Underline", self,
checkable=True, shortcut="Ctrl+U",
triggered=self.handleFontChange)
self.aboutAction = QAction("A&bout", self, shortcut="Ctrl+B",
triggered=self.about)
def createMenus(self):
self.fileMenu = self.menuBar().addMenu("&File")
self.fileMenu.addAction(self.exitAction)
self.itemMenu = self.menuBar().addMenu("&Item")
self.itemMenu.addAction(self.deleteAction)
self.itemMenu.addSeparator()
self.itemMenu.addAction(self.toFrontAction)
self.itemMenu.addAction(self.sendBackAction)
self.aboutMenu = self.menuBar().addMenu("&Help")
self.aboutMenu.addAction(self.aboutAction)
def createToolbars(self):
self.editToolBar = self.addToolBar("Edit")
self.editToolBar.addAction(self.deleteAction)
self.editToolBar.addAction(self.toFrontAction)
self.editToolBar.addAction(self.sendBackAction)
self.fontCombo = QFontComboBox()
self.fontCombo.currentFontChanged.connect(self.currentFontChanged)
self.fontSizeCombo = QComboBox()
self.fontSizeCombo.setEditable(True)
for i in range(8, 30, 2):
self.fontSizeCombo.addItem(str(i))
validator = QIntValidator(2, 64, self)
self.fontSizeCombo.setValidator(validator)
self.fontSizeCombo.currentIndexChanged.connect(self.fontSizeChanged)
self.fontColorToolButton = QToolButton()
self.fontColorToolButton.setPopupMode(QToolButton.MenuButtonPopup)
self.fontColorToolButton.setMenu(
self.createColorMenu(self.textColorChanged, Qt.black))
self.textAction = self.fontColorToolButton.menu().defaultAction()
self.fontColorToolButton.setIcon(
self.createColorToolButtonIcon(':/images/textpointer.png',
Qt.black))
self.fontColorToolButton.setAutoFillBackground(True)
self.fontColorToolButton.clicked.connect(self.textButtonTriggered)
self.fillColorToolButton = QToolButton()
self.fillColorToolButton.setPopupMode(QToolButton.MenuButtonPopup)
self.fillColorToolButton.setMenu(
self.createColorMenu(self.itemColorChanged, Qt.white))
self.fillAction = self.fillColorToolButton.menu().defaultAction()
self.fillColorToolButton.setIcon(
self.createColorToolButtonIcon(':/images/floodfill.png',
Qt.white))
self.fillColorToolButton.clicked.connect(self.fillButtonTriggered)
self.lineColorToolButton = QToolButton()
self.lineColorToolButton.setPopupMode(QToolButton.MenuButtonPopup)
self.lineColorToolButton.setMenu(
self.createColorMenu(self.lineColorChanged, Qt.black))
self.lineAction = self.lineColorToolButton.menu().defaultAction()
self.lineColorToolButton.setIcon(
self.createColorToolButtonIcon(':/images/linecolor.png',
Qt.black))
self.lineColorToolButton.clicked.connect(self.lineButtonTriggered)
self.textToolBar = self.addToolBar("Font")
self.textToolBar.addWidget(self.fontCombo)
self.textToolBar.addWidget(self.fontSizeCombo)
self.textToolBar.addAction(self.boldAction)
self.textToolBar.addAction(self.italicAction)
self.textToolBar.addAction(self.underlineAction)
self.colorToolBar = self.addToolBar("Color")
self.colorToolBar.addWidget(self.fontColorToolButton)
self.colorToolBar.addWidget(self.fillColorToolButton)
self.colorToolBar.addWidget(self.lineColorToolButton)
pointerButton = QToolButton()
pointerButton.setCheckable(True)
pointerButton.setChecked(True)
pointerButton.setIcon(QIcon(':/images/pointer.png'))
linePointerButton = QToolButton()
linePointerButton.setCheckable(True)
linePointerButton.setIcon(QIcon(':/images/linepointer.png'))
self.pointerTypeGroup = QButtonGroup()
self.pointerTypeGroup.addButton(pointerButton, DiagramScene.MoveItem)
self.pointerTypeGroup.addButton(linePointerButton,
DiagramScene.InsertLine)
self.pointerTypeGroup.buttonClicked[int].connect(self.pointerGroupClicked)
self.sceneScaleCombo = QComboBox()
self.sceneScaleCombo.addItems(["50%", "75%", "100%", "125%", "150%"])
self.sceneScaleCombo.setCurrentIndex(2)
self.sceneScaleCombo.currentIndexChanged[str].connect(self.sceneScaleChanged)
self.pointerToolbar = self.addToolBar("Pointer type")
self.pointerToolbar.addWidget(pointerButton)
self.pointerToolbar.addWidget(linePointerButton)
self.pointerToolbar.addWidget(self.sceneScaleCombo)
def createBackgroundCellWidget(self, text, image):
button = QToolButton()
button.setText(text)
button.setIcon(QIcon(image))
button.setIconSize(QSize(50, 50))
button.setCheckable(True)
self.backgroundButtonGroup.addButton(button)
layout = QGridLayout()
layout.addWidget(button, 0, 0, Qt.AlignHCenter)
layout.addWidget(QLabel(text), 1, 0, Qt.AlignCenter)
widget = QWidget()
widget.setLayout(layout)
return widget
def createCellWidget(self, text, diagramType):
item = DiagramItem(diagramType, self.itemMenu)
icon = QIcon(item.image())
button = QToolButton()
button.setIcon(icon)
button.setIconSize(QSize(50, 50))
button.setCheckable(True)
self.buttonGroup.addButton(button, diagramType)
layout = QGridLayout()
layout.addWidget(button, 0, 0, Qt.AlignHCenter)
layout.addWidget(QLabel(text), 1, 0, Qt.AlignCenter)
widget = QWidget()
widget.setLayout(layout)
return widget
def createColorMenu(self, slot, defaultColor):
colors = [Qt.black, Qt.white, Qt.red, Qt.blue, Qt.yellow]
names = ["black", "white", "red", "blue", "yellow"]
colorMenu = QMenu(self)
for color, name in zip(colors, names):
action = QAction(self.createColorIcon(color), name, self,
triggered=slot)
action.setData(QColor(color))
colorMenu.addAction(action)
if color == defaultColor:
colorMenu.setDefaultAction(action)
return colorMenu
def createColorToolButtonIcon(self, imageFile, color):
pixmap = QPixmap(50, 80)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
image = QPixmap(imageFile)
target = QRect(0, 0, 50, 60)
source = QRect(0, 0, 42, 42)
painter.fillRect(QRect(0, 60, 50, 80), color)
painter.drawPixmap(target, image, source)
painter.end()
return QIcon(pixmap)
def createColorIcon(self, color):
pixmap = QPixmap(20, 20)
painter = QPainter(pixmap)
painter.setPen(Qt.NoPen)
painter.fillRect(QRect(0, 0, 20, 20), color)
painter.end()
return QIcon(pixmap)
class MDFA(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
#%%
def cargarSenial(self):
self.aux = False
self.list3.clear()
self.list_MDFA.clear()
self.plot1.clear()
self.nombreSenial = QFileDialog.getOpenFileNames(
None, 'Open file(s)', '/home')
self.rutas = self.nombreSenial[0]
self.dialog = Dialog(
str(len(self.rutas)) + ' Files(s) loaded', 'open.png')
self.dialog.show()
self.list3.addItem('')
for i in range(len(self.rutas)):
names = str.split(self.rutas[i], "/")
t = len(names)
nombre = names[t - 1]
self.list3.addItem(nombre)
if (len(self.rutas) == 0):
self.lbl_num_files.setStyleSheet("color : red; ")
self.lbl_num_files.setText("Files loaded: " + str(len(self.rutas)))
else:
self.lbl_num_files.setStyleSheet("color : blue; ")
self.lbl_num_files.setText("Files loaded: " + str(len(self.rutas)))
self.aux = True
self.btnMDFA.setEnabled(True)
#%%
def plots(self):
if (self.aux == True):
self.plot1.clear()
i = self.list3.currentIndex() - 1
if (len(self.rutas) != 0):
data = pd.read_csv(self.rutas[i], sep='\t', header=None)
lineas = data.shape[1]
if (lineas == 1):
self.y = np.asarray(data[0])
elif (lineas == 2):
self.y = np.asarray(data[1])
self.plot1.setLabel('bottom',
color='k',
**{'font-size': '14pt'})
self.plot1.getAxis('bottom').setPen(
pg.mkPen(color='k', width=1))
# Y1 axis
self.plot1.setLabel('left', color='k', **{'font-size': '14pt'})
self.plot1.getAxis('left').setPen(pg.mkPen(color='k', width=1))
names = str.split(self.rutas[i], "/")
t = len(names)
nombre = names[t - 1]
self.plot1.setTitle(nombre)
self.plot1.plot(self.y, pen='k')
#%%
def print_val(self):
print(str(self.plots.checkedId()))
#%%
def MDFA(self):
self.t_inicial = time()
self.plot1.clear()
qmax = int(self.txtQmax.text())
qmin = int(self.txtQmin.text())
dq = float(self.txtdQ.text())
q = np.arange(qmin, qmax, dq)
m = int(self.txtm.text())
xn = np.arange(0, 135, 1)
func = np.vectorize(lambda x: int(10.1 * math.exp(0.0866 * x)))
n = func(xn)
self.alphas = np.transpose(np.zeros((len(q) - 1, len(self.rutas))))
self.fespectros = np.transpose(np.zeros((len(q) - 1, len(self.rutas))))
self.qs = np.transpose(np.zeros((len(q) - 1, len(self.rutas))))
self.taus = np.transpose(np.zeros((len(q) - 1, len(self.rutas))))
self.hches = np.transpose(np.zeros((len(q) - 1, len(self.rutas))))
for i in range(len(self.rutas)):
R = []
self.y = np.asarray(
pd.read_csv(self.rutas[i], sep='\t', header=None))
val = len(self.y) / 4
s = n[n < val]
if (self.int_state == 0):
Y = np.cumsum((self.y - np.mean(self.y)))
elif (self.int_state == 1):
Y = np.cumsum((self.y - np.mean(self.y)))
Y = np.cumsum((Y - np.mean(Y)))
YRev = Y
N = len(Y)
q = np.arange(qmin, qmax, dq)
Fq = np.zeros((len(s), len(q)))
znumb = np.where((q >= -0.1) & (q <= 0.1))[0][-1] - 1
for ns in range(len(s)):
Ns = int(N / s[ns])
Var = np.zeros((Ns, len(q)))
Varr = np.zeros((Ns, len(q)))
for v in range(Ns):
SegNumb = np.arange(((v + 1) - 1) * s[ns], (v + 1) * s[ns])
Seg = Y[SegNumb]
SegRev = YRev[SegNumb]
poly = np.polyfit(SegNumb, Seg, m)
polyr = np.polyfit(SegNumb, SegRev, m)
fit = np.polyval(poly, SegNumb)
fitr = np.polyval(polyr, SegNumb)
myfunc(q, Var, Varr, v, Seg, fit, s, ns, SegRev, fitr)
Var = np.transpose(Var)
Varr = np.transpose(Varr)
for nq in range(len(q)):
Fq[ns][nq] = pow(
(sum(Var[:][nq]) + sum(Varr[:][nq])) / (2 * Ns),
1 / q[nq])
Fq[ns][znumb] = (Fq[ns][znumb - 1] + Fq[ns][znumb + 1]) / 2
del (Var, Varr)
logFq = np.log10(Fq)
logFq = np.transpose(logFq)
Hq = np.zeros(len(q))
fes = []
eses = []
for nq in range(len(q)):
f = np.transpose(logFq[:][nq])
fes.append(f)
eses.append(np.log10(s))
P = np.polyfit(np.log10(s), logFq[:][nq], 1)
if (self.int_state == 0):
Hq[nq] = P[0]
elif (self.int_state == 1):
Hq[nq] = P[0] - 1
ajuste = []
for w in range(len(s)):
ajuste.append((Hq[nq] + 1) * np.log10(s[w]) + P[1])
rcuadrada = round(r2_score(f, ajuste), 4)
R.append(rcuadrada)
# fes = pd.DataFrame(fes)
# fes.to_csv(self.rutas[i]+'F(sq).txt', sep = '\t', index = False, header = None)
# eses = pd.DataFrame(eses)
# eses.to_csv(self.rutas[i]+'s.txt', sep = '\t', index = False, header = None)
# ajustes = pd.DataFrame(R)
# ajustes.to_csv(self.rutas[i]+'R_cuadrada.txt', sep = '\t', index = False, header = None)
t = q * Hq - 1
α = np.diff(t) / dq
Hq = Hq[0:len(Hq) - 1]
t = t[0:len(t) - 1]
q = q[0:len(q) - 1]
####### α y f(α) #############################################
fα = np.zeros(len(t))
fα = q * α - t
self.fα = fα
self.α = α
self.t = t
self.Hq = Hq
self.q = q
self.btnMDFA.setEnabled(False)
self.t_final = time()
self.tiempo = round(float(self.t_final - self.t_inicial), 4)
self.txttime.setText(str(self.tiempo))
self.alphas[:][i] = self.α
self.fespectros[:][i] = self.fα
self.taus[:][i] = self.t
self.hches[:][i] = self.Hq
self.qs[:][i] = self.q
self.list_MDFA.addItem('')
for i in range(len(self.rutas)):
names = str.split(self.rutas[i], "/")
t = len(names)
nombre = names[t - 1]
self.list_MDFA.addItem(nombre)
self.alphas = np.transpose(self.alphas)
self.fespectros = np.transpose(self.fespectros)
self.taus = np.transpose(self.taus)
self.hches = np.transpose(self.hches)
self.qs = np.transpose(self.qs)
self.dialogo_done = Dialog('Done!!', 'Icons\listo.png')
self.dialogo_done.show()
#%%
def plots_MDFA(self):
self.alphas2 = np.transpose(self.alphas)
self.fespectros2 = np.transpose(self.fespectros)
self.taus2 = np.transpose(self.taus)
self.hches2 = np.transpose(self.hches)
self.qs2 = np.transpose(self.qs)
op = self.plots.checkedId()
if (op == -2):
if (self.aux == True):
self.plot1.clear()
i = self.list_MDFA.currentIndex() - 1
if (len(self.rutas) != 0):
self.plot1.setLabel('bottom',
'α',
color='k',
**{'font-size': '14pt'})
self.plot1.getAxis('bottom').setPen(
pg.mkPen(color='k', width=1))
# Y1 axis
self.plot1.setLabel('left',
'f(α)',
color='k',
**{'font-size': '14pt'})
self.plot1.getAxis('left').setPen(
pg.mkPen(color='k', width=1))
names = str.split(self.rutas[i], "/")
t = len(names)
nombre = names[t - 1]
self.plot1.setTitle(nombre)
self.plot1.plot(self.alphas2[i],
self.fespectros2[i],
pen='r',
symbol='o',
symbolSize=10)
elif (op == -3):
if (self.aux == True):
self.plot1.clear()
i = self.list_MDFA.currentIndex() - 1
if (len(self.rutas) != 0):
self.plot1.setLabel('bottom',
'q',
color='k',
**{'font-size': '14pt'})
self.plot1.getAxis('bottom').setPen(
pg.mkPen(color='k', width=1))
# Y1 axis
self.plot1.setLabel('left',
'τ(q)',
color='k',
**{'font-size': '14pt'})
self.plot1.getAxis('left').setPen(
pg.mkPen(color='k', width=1))
names = str.split(self.rutas[i], "/")
t = len(names)
nombre = names[t - 1]
self.plot1.setTitle(nombre)
self.plot1.plot(self.qs2[i],
self.taus2[i],
pen='r',
symbol='o',
symbolSize=10)
elif (op == -4):
if (self.aux == True):
self.plot1.clear()
i = self.list_MDFA.currentIndex() - 1
if (len(self.rutas) != 0):
self.plot1.setLabel('bottom',
'q',
color='k',
**{'font-size': '14pt'})
self.plot1.getAxis('bottom').setPen(
pg.mkPen(color='k', width=1))
self.plot1.setLabel('left',
'h(q)',
color='k',
**{'font-size': '14pt'})
self.plot1.getAxis('left').setPen(
pg.mkPen(color='k', width=1))
names = str.split(self.rutas[i], "/")
t = len(names)
nombre = names[t - 1]
self.plot1.setTitle(nombre)
self.plot1.plot(self.qs2[i],
self.hches2[i],
pen='r',
symbol='o',
symbolSize=10)
#%%
def saveFile(self):
nom = QFileDialog.getSaveFileName(None, 'Saving Data in Current Plot')
writer = pd.ExcelWriter(nom[0] + ".xlsx")
a = pd.DataFrame(self.alphas)
a.to_excel(writer, 'Atable', index=False, header=None)
f = pd.DataFrame(self.fespectros)
f.to_excel(writer, 'Ftable', index=False, header=None)
t = pd.DataFrame(self.taus)
t.to_excel(writer, 'Ttable', index=False, header=None)
H = pd.DataFrame(self.hches)
H.to_excel(writer, 'Htable', index=False, header=None)
q = pd.DataFrame(self.qs)
q.to_excel(writer, 'Qtable', index=False, header=None)
writer.save()
#%%
def state_check(self, state):
if (state == Qt.Checked):
self.int_state = 1
else:
self.int_state = 0
#%%
def initUI(self):
pg.setConfigOption('background', 'w')
self.setWindowTitle('Multifractal Detrended Analysis Fluctuation')
self.setWindowIcon(QIcon("Icons\multifractal.ico"))
########Variables Globales ####################################################
###############################################################################
self.rutas = None
self.nombreSenial = ''
self.int_state = 0
contain = QSplitter(Qt.Horizontal)
botones = QVBoxLayout()
graficos = QVBoxLayout()
results1 = QFormLayout()
results2 = QFormLayout()
results3 = QFormLayout()
group_box_files = QGroupBox("Load file(s)")
group_box_settings = QGroupBox("Settings")
group_box_plots = QGroupBox("Plots")
#################################################################
## Elementos del layout botones
#################################################################
font_size = 'font-size: 18px'
self.btnLoadSig = QPushButton('Load signal')
self.btnLoadSig.clicked.connect(self.cargarSenial)
self.btnLoadSig.setStyleSheet(font_size)
self.btnLoadSig.setEnabled(True)
self.btnMDFA = QPushButton('MFDFA')
self.btnMDFA.clicked.connect(self.MDFA)
self.btnMDFA.setStyleSheet(font_size)
self.btnMDFA.setEnabled(False)
self.btnSavechar = QPushButton('Save data')
self.btnSavechar.clicked.connect(self.saveFile)
self.btnSavechar.setStyleSheet(font_size)
self.txtQmax = QLineEdit('5')
self.txtQmax.setEnabled(True)
self.txtQmax.setStyleSheet(font_size)
self.txtQmin = QLineEdit('-5')
self.txtQmin.setEnabled(True)
self.txtQmin.setStyleSheet(font_size)
self.txtdQ = QLineEdit('0.1')
self.txtdQ.setEnabled(True)
self.txtdQ.setStyleSheet(font_size)
self.txtm = QLineEdit('1')
self.txtm.setEnabled(True)
self.txtm.setStyleSheet(font_size)
lbl_check1 = QLabel("Nonstationary ts:")
lbl_check1.setStyleSheet(font_size)
self.check1 = QCheckBox()
self.check1.stateChanged.connect(self.state_check)
self.lbl_num_files = QLabel("Files loaded: ")
self.lbl_num_files.setStyleSheet(font_size)
lbl_file = QLabel("File: ")
lbl_file.setStyleSheet("font-size: 18px")
self.list3 = QComboBox()
self.list3.currentIndexChanged.connect(self.plots)
self.lbltime = QLabel("Exe. time:")
self.lbltime.setStyleSheet(font_size)
self.txttime = QLabel("")
self.txttime.setStyleSheet(font_size)
b1 = QRadioButton("f(α) Vs α")
b1.setStyleSheet(font_size)
b2 = QRadioButton("τ(q) Vs q")
b2.setStyleSheet(font_size)
b3 = QRadioButton("h(q) Vs q")
b3.setStyleSheet(font_size)
self.plots = QButtonGroup()
self.plots.addButton(b1)
self.plots.addButton(b2)
self.plots.addButton(b3)
self.plots.exclusive()
self.plots.buttonClicked.connect(self.print_val)
lbl_MDFA = QLabel("File: ")
lbl_MDFA.setStyleSheet(font_size)
self.list_MDFA = QComboBox()
self.list_MDFA.currentIndexChanged.connect(self.plots_MDFA)
#################################################################
## Elementos del layout graficos
#################################################################
self.plot1 = pg.PlotWidget()
self.plot1.setLabel('bottom', " ", color='k', **{'font-size': '20pt'})
self.plot1.getAxis('bottom').setPen(pg.mkPen(color='k', width=1))
# Y1 axis
self.plot1.setLabel('left', " ", color='k', **{'font-size': '20pt'})
self.plot1.getAxis('left').setPen(pg.mkPen(color='k', width=1))
self.plot1.showGrid(1, 1, 0.2)
#################################################################
## Colocar elementos en layout botones
#################################################################
results1.addRow(self.btnLoadSig)
results1.addRow(self.lbl_num_files)
results1.addRow(lbl_file, self.list3)
group_box_files.setLayout(results1)
results2.addRow(lbl_check1, self.check1)
results2.addRow('Q+:', self.txtQmax)
results2.addRow('Q-:', self.txtQmin)
results2.addRow('dQ:', self.txtdQ)
results2.addRow('m:', self.txtm)
results2.addRow(self.lbltime, self.txttime)
group_box_settings.setLayout(results2)
results3.addRow(lbl_MDFA, self.list_MDFA)
results3.addRow(b1)
results3.addRow(b2)
results3.addRow(b3)
group_box_plots.setLayout(results3)
botones.addWidget(group_box_files)
botones.addWidget(group_box_settings)
botones.addWidget(group_box_plots)
botones.addWidget(self.btnMDFA)
botones.addWidget(self.btnSavechar)
#################################################################
## Colocar elementos en layout graficos
#################################################################
graficos.addWidget(self.plot1)
bot = QWidget()
bot.setLayout(botones)
gra = QWidget()
gra.setLayout(graficos)
contain.addWidget(bot)
contain.addWidget(gra)
self.setCentralWidget(contain)
class Ui_Widget(object):
""" Klasa definiująca GUI """
def setupUi(self, Widget):
# widgety rysujące kształty, instancje klasy Ksztalt
self.ksztalt1 = Ksztalt(self, Ksztalty.Polygon)
self.ksztalt2 = Ksztalt(self, Ksztalty.Ellipse)
self.ksztaltAktywny = self.ksztalt1
# przyciski CheckBox ###
uklad = QVBoxLayout() # układ pionowy
self.grupaChk = QButtonGroup()
for i, v in enumerate(('Kwadrat', 'Koło', 'Trójkąt', 'Linia')):
self.chk = QCheckBox(v)
self.grupaChk.addButton(self.chk, i)
uklad.addWidget(self.chk)
self.grupaChk.buttons()[self.ksztaltAktywny.ksztalt].setChecked(True)
# CheckBox do wyboru aktywnego kształtu
self.ksztaltChk = QCheckBox('<=')
self.ksztaltChk.setChecked(True)
uklad.addWidget(self.ksztaltChk)
# układ poziomy dla kształtów oraz przycisków CheckBox
ukladH1 = QHBoxLayout()
ukladH1.addWidget(self.ksztalt1)
ukladH1.addLayout(uklad)
ukladH1.addWidget(self.ksztalt2)
# koniec CheckBox ###
# Slider i LCDNumber ###
self.suwak = QSlider(Qt.Horizontal)
self.suwak.setMinimum(0)
self.suwak.setMaximum(255)
self.lcd = QLCDNumber()
self.lcd.setSegmentStyle(QLCDNumber.Flat)
# układ poziomy (splitter) dla slajdera i lcd
ukladH2 = QSplitter(Qt.Horizontal, self)
ukladH2.addWidget(self.suwak)
ukladH2.addWidget(self.lcd)
ukladH2.setSizes((125, 75))
# przyciski RadioButton ###
self.ukladR = QHBoxLayout()
for v in ('R', 'G', 'B'):
self.radio = QRadioButton(v)
self.ukladR.addWidget(self.radio)
self.ukladR.itemAt(0).widget().setChecked(True)
# grupujemy przyciski
self.grupaRBtn = QGroupBox('Opcje RGB')
self.grupaRBtn.setLayout(self.ukladR)
self.grupaRBtn.setObjectName('Radio')
self.grupaRBtn.setCheckable(True)
# układ poziomy dla grupy Radio
ukladH3 = QHBoxLayout()
ukladH3.addWidget(self.grupaRBtn)
# koniec RadioButton ###
# Lista ComboBox i SpinBox ###
self.listaRGB = QComboBox(self)
for v in ('R', 'G', 'B'):
self.listaRGB.addItem(v)
self.listaRGB.setEnabled(False)
# SpinBox
self.spinRGB = QSpinBox()
self.spinRGB.setMinimum(0)
self.spinRGB.setMaximum(255)
self.spinRGB.setEnabled(False)
# układ pionowy dla ComboBox i SpinBox
uklad = QVBoxLayout()
uklad.addWidget(self.listaRGB)
uklad.addWidget(self.spinRGB)
# do układu poziomego grupy Radio dodajemy układ ComboBox i SpinBox
ukladH3.insertSpacing(1, 25)
ukladH3.addLayout(uklad)
# koniec ComboBox i SpinBox ###
# przyciski PushButton ###
uklad = QHBoxLayout()
self.grupaP = QButtonGroup()
self.grupaP.setExclusive(False)
for v in ('R', 'G', 'B'):
self.btn = QPushButton(v)
self.btn.setCheckable(True)
self.grupaP.addButton(self.btn)
uklad.addWidget(self.btn)
# grupujemy przyciski
self.grupaPBtn = QGroupBox('Przyciski RGB')
self.grupaPBtn.setLayout(uklad)
self.grupaPBtn.setObjectName('Push')
self.grupaPBtn.setCheckable(True)
self.grupaPBtn.setChecked(False)
# koniec PushButton ###
# główny układ okna, wertykalny ###
ukladOkna = QVBoxLayout()
ukladOkna.addLayout(ukladH1)
ukladOkna.addWidget(ukladH2)
ukladOkna.addLayout(ukladH3)
ukladOkna.addWidget(self.grupaPBtn)
self.setLayout(ukladOkna) # przypisanie układu do okna głównego
self.setWindowTitle('Widżety')
class MyWidget(QMainWindow):
def __init__(self):
super().__init__()
uic.loadUi('map.ui', self)
# Настройка элементов меню
self.radiobutton_group = QButtonGroup()
self.radiobutton_group.addButton(self.rb_1)
self.radiobutton_group.addButton(self.rb_2)
self.radiobutton_group.addButton(self.rb_3)
self.radiobutton_group.buttonClicked.connect(
self._on_radio_button_clicked)
self.btn_find.clicked.connect(self._on_btn_find_clicked)
self.btn_reset.clicked.connect(self._on_btn_reset_clicked)
self.checkBox.stateChanged.connect(self._on_checkbox_clicked)
# Логические переменные
self.toponym = None
self.geocoder_api = 'https://geocode-maps.yandex.ru/1.x/'
self.geocoder_apikey = "40d1649f-0493-4b70-98ba-98533de7710b"
self.geocoder_params = {
'apikey': self.geocoder_apikey,
'format': 'json'
}
self.static_api = 'https://static-maps.yandex.ru/1.x/'
self.static_params = {
'z': '13',
'l': 'map',
'll': '37.620070,55.753630',
'size': '480,450',
}
self.spn = {
0: 90,
1: 89.6,
2: 44.8,
3: 22.4,
4: 11.2,
5: 5.6,
6: 2.8,
7: 1.4,
8: 0.7,
9: 0.4,
10: 0.2,
11: 0.1,
12: 0.05,
13: 0.03,
14: 0.02,
15: 0.01,
16: 0.005,
17: 0.002
}
self.metr = 0.000006
self.wsim = self.metr * 450 # window size in metres
# Настройки окна
self.setFixedSize(720, 450)
self.updateMap()
def _on_checkbox_clicked(self):
try:
if self.toponym is not None:
text = self.toponym["metaDataProperty"]["GeocoderMetaData"][
"text"]
try:
if self.checkBox.isChecked():
postcode = self.toponym["metaDataProperty"][
"GeocoderMetaData"]["Address"]["postal_code"]
text = postcode + ' ' + text
except Exception:
pass
self.addressText.setPlainText(text)
except Exception as e:
print(e)
def _on_btn_reset_clicked(self):
try:
self.toponym = None
self.static_params.pop('pt', None)
self.addressText.setPlainText('')
self.updateMap()
except Exception as e:
print(e)
def find_place(self):
response = requests.get(self.geocoder_api,
params=self.geocoder_params,
timeout=0.4)
json_resp = response.json()
self.toponym = json_resp["response"]["GeoObjectCollection"][
"featureMember"][0]["GeoObject"]
text = self.toponym["metaDataProperty"]["GeocoderMetaData"]["text"]
try:
if self.checkBox.isChecked():
postcode = self.toponym["metaDataProperty"][
"GeocoderMetaData"]["Address"]["postal_code"]
text = postcode + ' ' + text
except Exception:
pass
self.addressText.setPlainText(text)
return list(map(float, self.toponym["Point"]["pos"].split()))
def _on_btn_find_clicked(self):
try:
if self.lineToFind.text():
self.geocoder_params['geocode'] = self.lineToFind.text()
lon, lat = self.find_place()
self.static_params['pt'] = f'{lon},{lat},pm2vvm'
self.static_params['ll'] = f'{lon},{lat}'
self.updateMap()
except Exception as e:
print(e)
def _on_radio_button_clicked(self, button):
if button.text() == 'Схема':
self.static_params['l'] = 'map'
elif button.text() == 'Спутник':
self.static_params['l'] = 'sat'
elif button.text() == 'Гибрид':
self.static_params['l'] = 'sat,skl'
self.updateMap()
def _on_right_click(self, event):
pass
def _on_left_click(self, event):
try:
z = int(self.static_params['z'])
x, y = list(map(float, self.static_params['ll'].split(',')))
m_x, m_y = event.pos().x(), event.pos().y()
if not 0 < m_x < 451:
return
delta_x = (x - self.spn[z] / 2)
lon = ((x - delta_x) * m_x / 225) + delta_x
print(lon, x)
lat = y + (225 - m_y) * self.spn[z] * 0.0045 / 2
self.geocoder_params['geocode'] = f'{lon},{lat}'
self.find_place()
self.static_params['pt'] = f'{lon},{lat},pm2vvm'
self.updateMap()
except Exception as e:
print(e)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self._on_left_click(event)
elif event.button() == Qt.RightButton:
self._on_right_click(event)
def keyPressEvent(self, event):
try:
z = int(self.static_params['z'])
x, y = list(map(float, self.static_params['ll'].split(',')))
if event.key() == Qt.Key_PageUp:
z += 1 if z < 17 else 0
self.static_params['z'] = str(z)
self.updateMap()
elif event.key() == Qt.Key_PageDown:
z += -1 if z > 0 else 0
self.static_params['z'] = str(z)
self.updateMap()
elif event.key() == Qt.Key_Up:
y += self.wsim * 2**(
17 - z) if y + self.wsim * 2**(17 - z) < 90 else 0
self.static_params['ll'] = f'{x},{y}'
self.updateMap()
elif event.key() == Qt.Key_Down:
y -= self.wsim * 2**(
17 - z) if y - self.wsim * 2**(17 - z) > -90 else 0
self.static_params['ll'] = f'{x},{y}'
self.updateMap()
elif event.key() == Qt.Key_Right:
x += self.wsim * 2**(
17 - z) if x + self.wsim * 2**(17 - z) < 180 else 0
self.static_params['ll'] = f'{x},{y}'
self.updateMap()
elif event.key() == Qt.Key_Left:
x -= self.wsim * 2**(
17 - z) if x - self.wsim * 2**(17 - z) > 0 else 0
self.static_params['ll'] = f'{x},{y}'
self.updateMap()
except Exception as e:
print(e)
def updateMap(self):
response = requests.get(self.static_api,
params=self.static_params,
timeout=0.4)
pixmap = QPixmap()
f = BytesIO(response.content)
f.seek(0)
pixmap.loadFromData(f.read())
self.map.setPixmap(pixmap)
def request_trezor_init_settings(self, wizard, method, device):
vbox = QVBoxLayout()
next_enabled = True
label = QLabel(_("Enter a label to name your device:"))
name = QLineEdit()
hl = QHBoxLayout()
hl.addWidget(label)
hl.addWidget(name)
hl.addStretch(1)
vbox.addLayout(hl)
def clean_text(widget):
text = widget.toPlainText().strip()
return ' '.join(text.split())
if method in [TIM_NEW, TIM_RECOVER]:
gb = QGroupBox()
hbox1 = QHBoxLayout()
gb.setLayout(hbox1)
# KeepKey recovery doesn't need a word count
if method == TIM_NEW:
vbox.addWidget(gb)
gb.setTitle(_("Select your seed length:"))
bg = QButtonGroup()
for i, count in enumerate([12, 18, 24]):
rb = QRadioButton(gb)
rb.setText(_("{} words").format(count))
bg.addButton(rb)
bg.setId(rb, i)
hbox1.addWidget(rb)
rb.setChecked(True)
cb_pin = QCheckBox(_('Enable PIN protection'))
cb_pin.setChecked(True)
else:
text = QTextEdit()
text.setMaximumHeight(60)
if method == TIM_MNEMONIC:
msg = _("Enter your BIP39 mnemonic:")
else:
msg = _("Enter the master private key beginning with xprv:")
def set_enabled():
from electrum.bip32 import is_xprv
wizard.next_button.setEnabled(is_xprv(clean_text(text)))
text.textChanged.connect(set_enabled)
next_enabled = False
vbox.addWidget(QLabel(msg))
vbox.addWidget(text)
pin = QLineEdit()
pin.setValidator(QRegExpValidator(QRegExp('[1-9]{0,9}')))
pin.setMaximumWidth(100)
hbox_pin = QHBoxLayout()
hbox_pin.addWidget(QLabel(_("Enter your PIN (digits 1-9):")))
hbox_pin.addWidget(pin)
hbox_pin.addStretch(1)
if method in [TIM_NEW, TIM_RECOVER]:
vbox.addWidget(WWLabel(RECOMMEND_PIN))
vbox.addWidget(cb_pin)
else:
vbox.addLayout(hbox_pin)
passphrase_msg = WWLabel(PASSPHRASE_HELP_SHORT)
passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
passphrase_warning.setStyleSheet("color: red")
cb_phrase = QCheckBox(_('Enable passphrases'))
cb_phrase.setChecked(False)
vbox.addWidget(passphrase_msg)
vbox.addWidget(passphrase_warning)
vbox.addWidget(cb_phrase)
wizard.exec_layout(vbox, next_enabled=next_enabled)
if method in [TIM_NEW, TIM_RECOVER]:
item = bg.checkedId()
pin = cb_pin.isChecked()
else:
item = ' '.join(str(clean_text(text)).split())
pin = str(pin.text())
return (item, name.text(), pin, cb_phrase.isChecked())
def request_trezor_init_settings(self, wizard, method, device):
vbox = QVBoxLayout()
next_enabled = True
label = QLabel(_("Enter a label to name your device:"))
name = QLineEdit()
hl = QHBoxLayout()
hl.addWidget(label)
hl.addWidget(name)
hl.addStretch(1)
vbox.addLayout(hl)
def clean_text(widget):
text = widget.toPlainText().strip()
return ' '.join(text.split())
if method in [TIM_NEW, TIM_RECOVER]:
gb = QGroupBox()
hbox1 = QHBoxLayout()
gb.setLayout(hbox1)
# KeepKey recovery doesn't need a word count
if method == TIM_NEW:
vbox.addWidget(gb)
gb.setTitle(_("Select your seed length:"))
bg = QButtonGroup()
for i, count in enumerate([12, 18, 24]):
rb = QRadioButton(gb)
rb.setText(_("{} words").format(count))
bg.addButton(rb)
bg.setId(rb, i)
hbox1.addWidget(rb)
rb.setChecked(True)
cb_pin = QCheckBox(_('Enable PIN protection'))
cb_pin.setChecked(True)
else:
text = QTextEdit()
text.setMaximumHeight(60)
if method == TIM_MNEMONIC:
msg = _("Enter your BIP39 mnemonic:")
else:
msg = _("Enter the master private key beginning with xprv:")
def set_enabled():
from electroncash.bitcoin import is_xprv
wizard.next_button.setEnabled(is_xprv(clean_text(text)))
text.textChanged.connect(set_enabled)
next_enabled = False
vbox.addWidget(QLabel(msg))
vbox.addWidget(text)
pin = QLineEdit()
pin.setValidator(QRegExpValidator(QRegExp('[1-9]{0,9}')))
pin.setMaximumWidth(100)
hbox_pin = QHBoxLayout()
hbox_pin.addWidget(QLabel(_("Enter your PIN (digits 1-9):")))
hbox_pin.addWidget(pin)
hbox_pin.addStretch(1)
if method in [TIM_NEW, TIM_RECOVER]:
vbox.addWidget(WWLabel(RECOMMEND_PIN))
vbox.addWidget(cb_pin)
else:
vbox.addLayout(hbox_pin)
passphrase_msg = WWLabel(PASSPHRASE_HELP_SHORT)
passphrase_warning = WWLabel(PASSPHRASE_NOT_PIN)
passphrase_warning.setStyleSheet("color: red")
cb_phrase = QCheckBox(_('Enable passphrases'))
cb_phrase.setChecked(False)
vbox.addWidget(passphrase_msg)
vbox.addWidget(passphrase_warning)
vbox.addWidget(cb_phrase)
wizard.exec_layout(vbox, next_enabled=next_enabled)
if method in [TIM_NEW, TIM_RECOVER]:
item = bg.checkedId()
pin = cb_pin.isChecked()
else:
item = ' '.join(str(clean_text(text)).split())
pin = str(pin.text())
return (item, name.text(), pin, cb_phrase.isChecked())
class DifficultyWindow(QDialog):
def __init__(self):
super().__init__()
self.modes = {'Новичок': (9, 9, 10),
'Эксперт': (16, 16, 40),
'Бывалый': (16, 30, 99)
}
self.resize(389, 300)
self.init_ui()
def init_ui(self):
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setGeometry(-70, 260, 341, 32)
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok)
self.gridLayoutWidget_2 = QWidget(self)
self.gridLayoutWidget_2.setGeometry(130, 20, 121, 91)
self.gridLayout_2 = QGridLayout(self.gridLayoutWidget_2)
self.gridLayout_2.setContentsMargins(0, 0, 0, 0)
for i, row in enumerate([('Высота', 'Ширина', 'Мины'), *self.modes.values()]):
for j, col in enumerate(row):
label = QLabel(self.gridLayoutWidget_2)
label.setText(str(col))
label.setAlignment(QtCore.Qt.AlignCenter)
self.gridLayout_2.addWidget(label, i, j, 1, 1)
mode_label = QLabel(self)
mode_label.setGeometry(QtCore.QRect(65, 20, 61, 18))
mode_label.setText('Режим')
mode_label.setAlignment(QtCore.Qt.AlignLeading | QtCore.Qt.AlignCenter |
QtCore.Qt.AlignVCenter)
self.buttonGroup = QButtonGroup(self)
checkbutton_list = []
for n, key in enumerate([*self.modes.keys(), 'Особый']):
rb = QRadioButton(self)
self.buttonGroup.addButton(rb)
rb.setGeometry(60, 45 + 25 * n, 71, 17)
rb.setText(key)
checkbutton_list.append(rb)
self.easy, self.normal, self.hard, self.special = checkbutton_list
lcd_list, slider_list = [], []
for n, (minimum, maximum) in enumerate([(9, 21), (9, 46), (9, 27)]):
offset = 40 * n
slider = QSlider(self)
slider.setEnabled(False)
slider.setGeometry(70, 150 + offset, 248, 22)
slider.setMinimum(minimum)
slider.setMaximum(maximum)
slider.setOrientation(QtCore.Qt.Horizontal)
slider_list.append(slider)
label = QLabel(self)
label.setGeometry(22, 147 + offset, 47, 13)
label.setText(['Высота', 'Ширина', 'Бомбы'][n])
sublabel = QLabel(self)
sublabel.setGeometry(22, 157 + offset, 41, 16)
sublabel.setText(f'[{minimum}-{maximum}]')
lcd = QLCDNumber(self)
lcd.setGeometry(327, 148 + offset, 41, 21)
lcd.setDigitCount(3)
lcd.setSegmentStyle(QLCDNumber.Flat)
lcd.setProperty("intValue", 9)
lcd_list.append(lcd)
self.bombs_label = sublabel
self.height_slider, self.width_slider, self.bombs_slider = slider_list
self.height_lcd, self.width_lcd, self.bombs_lcd = lcd_list
self.buttonGroup.buttonClicked.connect(self.checked)
self.mode = (9, 9, 10)
self.setWindowTitle("Сложность")
self.easy.setChecked(True)
self.okay_clicked = False
for slider in [self.bombs_slider, self.width_slider, self.height_slider]:
slider.valueChanged.connect(self.recalculate_sliders)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def get_values(self):
self.exec()
return (self.get_okay_clicked(), *self.get_mode())
def accept(self):
self.okay_clicked = True
super().accept()
def checked(self):
if self.sender().checkedButton().text() == 'Особый':
for slider in [self.bombs_slider, self.width_slider, self.height_slider]:
slider.setEnabled(True)
else:
if self.bombs_slider.isEnabled():
for slider in [self.bombs_slider, self.width_slider, self.height_slider]:
slider.setEnabled(False)
self.mode = self.modes[self.sender().checkedButton().text()]
def get_mode(self):
return self.mode
def get_okay_clicked(self):
return self.okay_clicked
def recalculate_sliders(self):
width, height = self.width_slider.value(), self.height_slider.value()
bombs = self.bombs_slider.value()
self.width_lcd.display(width)
self.height_lcd.display(height)
self.bombs_lcd.display(bombs)
self.bombs_slider.setMaximum(width * height // 3 + 1)
self.bombs_label.setText(f'[9-{self.bombs_slider.maximum()}]')
self.mode = (height, width, bombs)
class LayoutPlugin(MainWindowPlugin):
def __init__(self, main_window, announces, api):
super().__init__(main_window, announces, api)
self.topology_ratio = QRadioButton('拓扑布局', main_window)
self.physical_ratio = QRadioButton('物理布局', main_window)
self.group_box = QButtonGroup(main_window)
self.group_box.addButton(self.topology_ratio)
self.group_box.addButton(self.physical_ratio)
self.group_box.buttonClicked.connect(self.buttonClickedSlot)
tool_bar = QToolBar(main_window)
tool_bar.setWindowTitle('位置工具栏')
tool_bar.addWidget(self.topology_ratio)
tool_bar.addWidget(self.physical_ratio)
main_window.addToolBar(Qt.TopToolBarArea, tool_bar)
self.topology_layout = None
self.last_clicked_ratio = None
self.pixmap = QPixmap(BACKGROUND_MAP_IMAGE)
announces['playSteps'].append(self.playSteps)
announces['sceneNodeMoved'].append(self.sceneNodeMoved)
def playSteps(self, steps):
if self.group_box.checkedButton() is None: # 设置默认模式
self.topology_layout = self._getTopologyLayout()
self.topology_ratio.click(
) # 导致 self.buttonClickedSlot(self.topology_ratio)
elif self.group_box.checkedButton() is self.physical_ratio: # 物理位置图
self.buttonClickedSlot(self.physical_ratio) # 重新加载位置图, 以更新位置信息
def buttonClickedSlot(self, ratio):
if (ratio is self.topology_ratio) and (ratio is
self.last_clicked_ratio):
self.topology_layout = self._getTopologyLayout() # 多次点击, 重新计算位置
self.api['Scene.setBackgroundPixmap'](self.getBackgroundPixmap())
self.api['Scene.setLayout'](self.getLayout())
self.last_clicked_ratio = ratio
def sceneNodeMoved(self, node_id, pos):
if self.group_box.checkedButton() is self.topology_ratio:
self.topology_layout[node_id] = pos # 拓扑图模式下修改缓存的位置信息
elif self.group_box.checkedButton() is self.physical_ratio:
icn_node = self.api['Sim.node'](node_id)
icn_node.pos = pos # 物理图模式下修改节点实际位置
self.announces['playSteps'](0)
else: # 没有模式被设置
pass
# -------------------------------------------------------------------------
def getLayout(self):
if self.group_box.checkedButton() is self.topology_ratio:
return self.topology_layout
elif self.group_box.checkedButton() is self.physical_ratio:
return self._getPhysicalLayout()
else: # 没有模式被设置
pass
def getBackgroundPixmap(self):
if self.group_box.checkedButton() is self.topology_ratio:
return None
elif self.group_box.checkedButton() is self.physical_ratio:
return self.pixmap
else: # 没有模式被设置
pass
# -------------------------------------------------------------------------
def _getPhysicalLayout(self) -> dict:
graph = self.api['Sim.graph']()
layout = {}
for node_id in graph:
icn_node = self.api['Sim.node'](node_id)
layout[node_id] = getattr(icn_node, 'pos', (0, 0))
return layout
def _getTopologyLayout(self) -> dict:
graph = self.api['Sim.graph']()
layout = networkx.spring_layout(graph, scale=300,
iterations=50) # scale 单位pix
# FIXME spring_layout 中, 利用已有pos迭代, 会出现扭曲. 参数: pos= self.topology_layout
return layout
class ToolbarTabManager(QObject):
""
def __init__(self, toolbar, parent=None):
super().__init__(parent)
self.parent_widget = parent
self.toolbar = toolbar
self._actions = []
self._last_selected = None
self.idx_widget = self.toolbar.addWidget(QWidget(self.toolbar))
self.idx_widget.setVisible(False)
self.agroup = QButtonGroup(self)
self.agroup.setExclusive(True)
self.library_btn = None
self.favorite_btn = self.addTab("Favorites", delegate_paint=False, icon=app_constants.STAR_ICON)
self.library_btn = self.addTab("Library", delegate_paint=False, icon=app_constants.GRIDL_ICON)
self.idx_widget = self.toolbar.addWidget(QWidget(self.toolbar))
self.idx_widget.setVisible(False)
self.toolbar.addSeparator()
def _manage_selected(self, b):
if self._last_selected == b:
return
if self._last_selected:
self._last_selected.selected = False
self._last_selected.view.list_view.sort_model.rowsInserted.disconnect(self.parent_widget.stat_row_info)
self._last_selected.view.list_view.sort_model.rowsRemoved.disconnect(self.parent_widget.stat_row_info)
self._last_selected.view.hide()
b.selected = True
self._last_selected = b
self.parent_widget.current_manga_view = b.view
b.view.list_view.sort_model.rowsInserted.connect(self.parent_widget.stat_row_info)
b.view.list_view.sort_model.rowsRemoved.connect(self.parent_widget.stat_row_info)
b.view.show()
def addTab(self, name, view_type=app_constants.ViewType.Default, delegate_paint=True, allow_sidebarwidget=False, icon=None):
if self.toolbar:
t = misc.ToolbarButton(self.toolbar, name)
if icon:
t.setIcon(icon)
else:
t.setIcon(app_constants.CIRCLE_ICON)
t.setCheckable(True)
self.agroup.addButton(t)
t.select.connect(self._manage_selected)
t.close_tab.connect(self.removeTab)
if self.library_btn:
t.view = gallery.MangaViews(view_type, self.parent_widget, allow_sidebarwidget)
t.view.hide()
t.close_tab.connect(lambda:self.library_btn.click())
if not allow_sidebarwidget:
t.clicked.connect(self.parent_widget.sidebar_list.arrow_handle.click)
else:
t.view = self.parent_widget.default_manga_view
if delegate_paint:
t.view.list_view.manga_delegate._paint_level = 9000 # over nine thousand!!!
self._actions.append(self.toolbar.insertWidget(self.idx_widget, t))
return t
def removeTab(self, button_or_index):
if self.toolbar:
if isinstance(button_or_index, int):
self.toolbar.removeAction(self._actions.pop(button_or_index))
else:
act_to_remove = None
for act in self._actions:
w = self.toolbar.widgetForAction(act)
if w == button_or_index:
self.toolbar.removeAction(act)
act_to_remove = act
break
if act_to_remove:
self._actions.remove(act)
class model_scene_media(Ui_MainWindow, QMainWindow):
off_open_list = pyqtSignal()
def __init__(self):
super(Ui_MainWindow, self).__init__()
self.setupUi(self)
self.setWindowFlags(Qt.WindowCloseButtonHint)
self.setFixedSize(self.width(), self.height())
self.default_config = read_config(constant.CONFIG_FILE)
self.videomode = None
self.attribute_init()
self.online_list = [
self.checkBox, self.checkBox_2, self.checkBox_3, self.checkBox_4,
self.checkBox_8, self.checkBox_9, self.checkBox_10,
self.checkBox_11, self.checkBox_12, self.checkBox_14,
self.checkBox_17, self.checkBox_15, self.checkBox_20,
self.checkBox_18
]
self.online_dict = {
"腾讯视频": False,
"爱奇艺": False,
"酷喵": False,
"QQ音乐MV": False,
"QQ音乐": False,
"HDP": False,
"电视家": False,
"本地视频_大码率": False,
"信源": False,
"本地视频_混合编解码": False,
"遥控器是否回连成功": False,
"近场唤醒是否成功": False,
"蓝牙音箱是否回连成功": False,
"远场唤醒是否成功": False
}
self.to_screen_list = [
self.checkBox_19, self.checkBox_22, self.checkBox_23,
self.checkBox_21, self.checkBox_16, self.checkBox_31,
self.checkBox_32
]
self.to_screen_dict = {
"乐播投屏": False,
"dlna投屏": False,
"miracast（无线投屏）": False,
"遥控器是否回连成功 ": False,
"近场唤醒是否成功": False,
"蓝牙音箱是否回连成功": False,
"远场唤醒是否成功": False
}
self.buttton_init()
def attribute_init(self):
self.performance_interval = self.default_config['scene_media'][
'performance_interval']['val']
self.performance_str = ''
self.a2dp_mac = None
self.local_video = {'本地视频_大码率': '', '本地视频_混合编解码': ''}
self.device_choice_ui = None
self.create_scene_view = None
def open_scene_list(self):
self.off_open_list.emit()
self.close()
def buttton_init(self):
from PyQt5.QtGui import QFont
self.setAttribute(Qt.WA_DeleteOnClose)
self.lineEdit_9.setFont(QFont("宋体", 10, QFont.Normal))
self.lineEdit_2.setFont(QFont("宋体", 14, QFont.Normal))
self.lineEdit_3.setFont(QFont("宋体", 14, QFont.Normal))
# self.lineEdit_9.setPlaceholderText('如勾选，请输入蓝牙音箱mac地址.')
self.lineEdit_9.setHidden(True)
self.setWindowTitle('多媒体兼容')
# icon = QIcon(constant.all_icon)
# self.setWindowIcon(icon)
self.setWindowIcon(
QIcon(os.path.join(constant.SRC_ROOT, 'icon', '多媒体兼容.ico')))
self.label_15.setHidden(True)
self.pushButton_2.clicked.connect(
lambda: self.jump_connect(self.pushButton_2.text()))
self.lineEdit.setPlaceholderText(
'起播命令输入到命令模板，模板路径‘安装工具路径/src/video_brand.json')
self.lineEdit_8.setPlaceholderText(
'路径输入顺序：大码率;混合编解码。两个路径以英文;分隔。选择大码率和混合编解码视频商必填')
for clickbox in self.online_list:
clickbox.stateChanged.connect(
lambda: self.online_checkbox(self.sender(),
self.sender().text()))
for clickbox2 in self.to_screen_list:
clickbox2.stateChanged.connect(
lambda: self.toscreen_checkbox(self.sender(),
self.sender().text()))
self.pushButton_8.clicked.connect(
lambda: self.online_video_scene(self.pushButton_8.text()))
self.pushButton_7.clicked.connect(
lambda: self.online_video_scene(self.pushButton_7.text()))
self.pushButton_9.clicked.connect(
lambda: self.to_screen_scene(self.pushButton_9.text()))
self.pushButton_10.clicked.connect(
lambda: self.to_screen_scene(self.pushButton_10.text()))
self.video_choice = QButtonGroup()
self.video_choice.addButton(self.radioButton_5, 0)
self.video_choice.addButton(self.radioButton_6, 1)
self.video_choice.buttonClicked[int].connect(self.set_video_mode)
def set_video_mode(self, int):
if int == 0:
self.videomode = True
else:
self.videomode = False
def message(self, title, text):
newMessagebox = QMessageBox(self)
newMessagebox.setText('\r\r\r' + text + '\r\r\r')
newMessagebox.setWindowTitle(title)
newMessagebox.setIcon(1)
newMessagebox.setStyleSheet(
'QMessageBox{background-color:rgb(240,240,240)}')
newMessagebox.setStandardButtons(QMessageBox.Yes)
newMessagebox.exec()
def online_checkbox(self, checkbox, text):
if checkbox.isChecked():
self.online_dict[text] = True
else:
self.online_dict[text] = False
def toscreen_checkbox(self, checkbox, text):
if checkbox.isChecked():
self.to_screen_dict[text] = True
else:
self.to_screen_dict[text] = False
def online_video_scene(self, value):
if not True in list(self.online_dict.values())[0:10]:
self.message('提示', '请勾选带*号的必选项：视频商')
return
if self.lineEdit_8.text() == "":
if self.online_dict["本地视频_大码率"] == True or self.online_dict[
"本地视频_混合编解码"] == True:
self.message('提示', '请填入已勾选的本地视频地址')
return
else:
locat_video_list = self.lineEdit_8.text().split(';')
len_locat_video_list = len(locat_video_list)
if len_locat_video_list > 3:
self.message('提示', '检查发现地址个数异常请先排查！')
return
for dir in locat_video_list:
len_locat_video_list = len_locat_video_list if dir != '' else len_locat_video_list - 1
if len_locat_video_list == 1 and self.online_dict[
"本地视频_大码率"] == True and self.online_dict[
"本地视频_混合编解码"] == True:
self.message('提示', '请填入正确的本地视频地址个数，根据已勾选本地视频！')
return
elif len_locat_video_list == 2 and self.online_dict[
"本地视频_大码率"] == True and self.online_dict[
"本地视频_混合编解码"] == True:
self.local_video['本地视频_大码率'] = locat_video_list[0]
self.local_video['本地视频_混合编解码'] = locat_video_list[1]
else:
if len_locat_video_list == 2:
self.message('提示', '请根据填入的地址数量，勾选本地视频项！')
return
elif self.online_dict["本地视频_大码率"] == True:
self.local_video['本地视频_大码率'] = self.lineEdit_8.text()
elif self.online_dict["本地视频_混合编解码"] == True:
self.local_video['本地视频_混合编解码'] = self.lineEdit_8.text()
else:
self.message('提示', '检查发现已输入地址，请勾选对应的本地视频项')
return
# if self.online_dict["蓝牙音箱是否回连成功"]:
# if not self.lineEdit_9.text():
# self.message('提示', '请输入蓝牙Mac地址！')
# else:
# self.a2dp_mac = self.lineEdit_9.text()
if self.lineEdit_2.text() != "":
try:
self.performance_interval = float(self.lineEdit_2.text()) * 60
except:
self.lineEdit_2.clear()
self.label_15.setHidden(False)
return
self.performance_str = self.lineEdit_3.text()
if value == "一键调试":
if self.view_close(self.device_choice_ui):
return
self.device_choice_ui = device_chooose_connect(self)
self.device_choice_ui.device_list_signal.connect(
self.create_online_scene)
self.device_choice_ui.show()
else:
if self.view_close(self.create_scene_view):
return
self.create_scene_view = create_scene_view('time', parent=self)
self.create_scene_view.scene_information.connect(
self.create_online_scene)
self.create_scene_view.show()
def view_close(self, view):
try:
if view != None:
if view.isVisible():
return True
else:
view.close()
return False
except:
return False
def to_screen_scene(self, value):
if self.video_choice.checkedId() == -1:
QMessageBox.information(None, '提示', '请勾选带*号的必选项：视频选择',
QMessageBox.Yes)
return
if value == "一键调试":
if self.view_close(self.device_choice_ui):
return
self.device_choice_ui = device_chooose_connect()
self.device_choice_ui.device_list_signal.connect(
self.create_toscreen_scene)
self.device_choice_ui.show()
else:
if self.view_close(self.create_scene_view):
return
self.create_scene_view = create_scene_view()
self.create_scene_view.scene_information.connect(
self.create_toscreen_scene)
self.create_scene_view.show()
def create_online_scene(self, devices_list, scene_name, exec_times):
this_checker = ck.Checker(
blue_controller=self.online_dict["遥控器是否回连成功"],
blue_speaker=self.online_dict["蓝牙音箱是否回连成功"],
near=self.online_dict["近场唤醒是否成功"],
far=self.online_dict["远场唤醒是否成功"],
)
brand_list = []
for channel in [
"腾讯视频", "爱奇艺", "酷喵", "QQ音乐MV", "QQ音乐", "HDP", "电视家",
"本地视频_大码率", "本地视频_混合编解码", "信源"
]:
if self.online_dict[channel] == True:
brand_list.append(channel)
if len(devices_list) == 0:
self.online_scene = scene_media.SceneMedia(
name=scene_name,
exec_time=exec_times,
by=sc.BY_TIME,
checker=this_checker,
brand_list=brand_list,
profile=self.lineEdit.text(),
performance_str=self.performance_str,
performance_interval=self.performance_interval,
local_video=self.local_video
# check_interval=self.lineEdit_2.text()
)
self.attribute_init()
self.online_scene.save()
self.creat_success_toast = toast(parent=self, text='视频煲机场景\n创建成功！')
self.creat_success_toast.move(
QPoint(self.geometry().left() + self.width() * 0.3,
self.geometry().top() + self.height() * 0.3))
self.creat_success_toast.ocl_signal.connect(self.open_scene_list)
self.creat_success_toast.exec()
else:
self.online_scene = scene_media.SceneMedia(
name="视频煲机",
exec_time=1,
checker=this_checker,
brand_list=brand_list,
profile=self.lineEdit.text(),
performance_str=self.performance_str,
performance_interval=self.performance_interval,
local_video=self.local_video)
self.attribute_init()
self.online_scene.device = dv.Device(devices_list[0][0],
devices_list[0][1])
self.checkscene = sceneOneCheck(self.online_scene)
self.checkscene.reflash_sig.connect(self.showlog)
self.checkscene.dependent_check_sig.connect(self.check_message)
self.checkscene.start()
def showlog(self):
self.debug_tootip = debug_tootip(self)
self.debug_tootip.move(self.width() * 0.3, self.height() * 0.3)
self.debug_tootip.exec()
def check_message(self, check):
self.message('依赖检查', check)
def inform_text(self, string):
if string == 'begin':
self.loading = loading(self)
self.loading.label_2.setText('调试中，请等待')
self.loading.move(self.width() * 0.45, self.height() * 0.45)
self.loading.exec()
if string == 'FAIL':
self.loading.label_2.setText('执行失败')
self.loading.close()
QMessageBox.information(self, '提示', '执行失败', QMessageBox.Yes)
return
if string == 'FINISH':
self.loading.label_2.setText('执行成功')
self.loading.close()
QMessageBox.information(self, '提示', '执行完成', QMessageBox.Yes)
return
def create_toscreen_scene(self, devices_list, scene_name, exec_times):
this_checker = ck.Checker(
launcher=True,
# blue_controller=self.online_dict["遥控器是否回连成功"],
# blue_speaker=self.online_dict["蓝牙音箱是否回连成功"],
# near=self.online_dict["近场唤醒是否成功"],
# far=self.online_dict["远场唤醒是否成功"],
)
# brand_list = []
# for channel in ["腾讯视频", "爱奇艺", "酷喵", "QQ音乐MV",
# "QQ音乐", "HDP", "电视家",
# "本地视频", "信源"]:
# if self.online_dict[channel] == True:
# brand_list.append(channel)
# print('brand_list', brand_list)
if self.videomode == True:
profile = ''
else:
profile = ''
if len(devices_list) == 0:
self.online_scene = scene_media.SceneMedia(
name=scene_name,
exec_time=exec_times,
by=sc.BY_COUNT,
profile=profile,
checker=this_checker,
brand_list=[],
performance_str=self.lineEdit_7.text(),
performance_interval=int(self.lineEdit_6.text()),
# check_interval=self.lineEdit_2.text()
)
self.online_scene.save()
else:
self.online_scene = scene_media.SceneMedia(
name="开机直达",
exec_time=1,
profile=profile,
checker=this_checker,
brand_list=[],
performance_str=self.lineEdit_7.text(),
performance_interval=int(self.lineEdit_6.text()),
# check_interval=self.lineEdit_2.text()
)
task = task_base.TaskBase(name=scene_name,
device=dv.Device(devices_list[0][0],
devices_list[0][1]),
scene_list=[self.online_scene])
# task.start()
try:
self.test = scene_test(task)
self.test.sig.connect(self.inform_text)
self.test.start()
except:
print(traceback.format_exc())
def jump_connect(self, str):
if str == "内置在线视频":
self.tabWidget.setCurrentIndex(0)
elif str == "投屏轮播":
self.tabWidget.setCurrentIndex(1)
elif str == "本地视频":
self.tabWidget.setCurrentIndex(2)
else:
pass
class ToggleToolBar(QWidget): index = 0 buttons = [] rows = [] maxRow = 7 maxCol = 4 selectedFrame = [] selectedButtons = [] def __init__(self): super(ToggleToolBar, self).__init__() self.setFixedSize(300,560) self.container = QVBoxLayout() self.container.setAlignment(Qt.AlignLeft) self.container.setSpacing(5) for i in range(0,self.maxRow): row = QHBoxLayout() row.setAlignment(Qt.AlignTop) row.setSpacing(5) self.container.addLayout(row) self.rows.append(row) self.buttonGroup = QButtonGroup() self.buttonGroup.setExclusive(False) self.setLayout(self.container) self.buttonGroup.buttonClicked[int].connect(self.imageSelected) def imageSelected(self,imgId): button = self.buttons[imgId] if button.pixMap in self.selectedFrame and (not button.isChecked()): self.selectedFrame.remove(button.pixMap) self.selectedButtons.remove(button) if (not (button.pixMap in self.selectedFrame)) and button.isChecked(): self.selectedFrame.append(button.pixMap) self.selectedButtons.append(button) def getSelected(self): return self.selectedFrame def clearAllSelected(self): for button in self.selectedButtons: button.setChecked(False) self.selectedButtons = [] self.selectedFrame = [] def addImageButton(self,image): imageButton = ImageToggleButton(self.index,image) self.buttonGroup.addButton(imageButton,self.index) self.rows[self.index//self.maxCol].addWidget(imageButton) self.buttons.append(imageButton) self.index += 1 def createImageButtons(self,imagePath): groupImg = QImage(imagePath) width = groupImg.width() height = groupImg.height() frameSize = width for i in range(0,height//width): img = groupImg.copy(0,i*frameSize,frameSize,frameSize); self.addImageButton(img) def removeAllButton(self): for i in range(0,self.index): row = self.rows[i // self.maxCol] row.removeWidget(self.buttons[i]) self.buttonGroup.removeButton(self.buttons[i]) self.buttons[i].close() self.buttons = [] self.index = 0
class RotamerDialog(ToolInstance):
help = "help:user/tools/rotamers.html"
SESSION_SAVE = True
registerer = "swap_res RotamerDialog"
def __init__(self, session, tool_name, *args):
ToolInstance.__init__(self, session, tool_name)
if args:
# being called directly rather than during session restore
self.finalize_init(*args)
def finalize_init(self, mgr, res_type, rot_lib, *, table_info=None):
self.mgr = mgr
self.res_type = res_type
self.rot_lib = rot_lib
self.subdialogs = {}
from collections import OrderedDict
self.opt_columns = OrderedDict()
self.handlers = [
self.mgr.triggers.add_handler('fewer rotamers',
self._fewer_rots_cb),
self.mgr.triggers.add_handler('self destroyed',
self._mgr_destroyed_cb),
]
from chimerax.ui.widgets import ItemTable
global _settings
if _settings is None:
from chimerax.core.settings import Settings
class _RotamerSettings(Settings):
EXPLICIT_SAVE = {ItemTable.DEFAULT_SETTINGS_ATTR: {}}
_settings = _RotamerSettings(self.session, "Rotamers")
from chimerax.ui import MainToolWindow
self.tool_window = tw = MainToolWindow(self)
parent = tw.ui_area
from PyQt5.QtWidgets import QVBoxLayout, QLabel, QCheckBox, QGroupBox, QWidget, QHBoxLayout, \
QPushButton, QRadioButton, QButtonGroup, QGridLayout
from PyQt5.QtCore import Qt
self.layout = layout = QVBoxLayout()
parent.setLayout(layout)
lib_display_name = self.session.rotamers.library(rot_lib).display_name
layout.addWidget(
QLabel("%s %s rotamers" % (lib_display_name, res_type)))
column_disp_widget = QWidget()
class RotamerTable(ItemTable):
def sizeHint(self):
from PyQt5.QtCore import QSize
return QSize(350, 450)
self.table = RotamerTable(column_control_info=(column_disp_widget,
_settings, {}, True,
None, None, False),
auto_multiline_headers=False)
for i in range(len(self.mgr.rotamers[0].chis)):
self.table.add_column("Chi %d" % (i + 1),
lambda r, i=i: r.chis[i],
format="%6.1f")
self.table.add_column("Probability", "rotamer_prob", format="%.6f ")
if table_info:
table_state, additional_col_info = table_info
for col_type, title, data_fetch, display_format in additional_col_info:
AtomicStructure.register_attr(
self.session,
data_fetch,
self.registerer,
attr_type=(int if data_fetch.startswith("num") else float))
self.opt_columns[col_type] = self.table.add_column(
title, data_fetch, format=display_format)
else:
table_state = None
self.table.data = self.mgr.rotamers
self.table.launch(session_info=table_state)
if not table_info:
self.table.sortByColumn(len(self.mgr.rotamers[0].chis),
Qt.DescendingOrder)
self.table.selection_changed.connect(self._selection_change)
layout.addWidget(self.table)
if mgr.base_residue.name == res_type:
self.retain_side_chain = QCheckBox("Retain original side chain")
self.retain_side_chain.setChecked(False)
layout.addWidget(self.retain_side_chain)
else:
self.retain_side_chain = None
column_group = QGroupBox("Column display")
layout.addWidget(column_group)
cg_layout = QVBoxLayout()
cg_layout.setContentsMargins(0, 0, 0, 0)
cg_layout.setSpacing(0)
column_group.setLayout(cg_layout)
cg_layout.addWidget(column_disp_widget)
add_col_layout = QGridLayout()
add_col_layout.setContentsMargins(0, 0, 0, 0)
add_col_layout.setSpacing(0)
cg_layout.addLayout(add_col_layout)
self.add_col_button = QPushButton("Calculate")
add_col_layout.addWidget(self.add_col_button,
0,
0,
alignment=Qt.AlignRight)
radio_layout = QVBoxLayout()
radio_layout.setContentsMargins(0, 0, 0, 0)
add_col_layout.addLayout(radio_layout, 0, 1, alignment=Qt.AlignLeft)
self.button_group = QButtonGroup()
self.add_col_button.clicked.connect(
lambda checked, *, bg=self.button_group: self._show_subdialog(
bg.checkedButton().text()))
for add_type in ["H-Bonds", "Clashes", "Density"]:
rb = QRadioButton(add_type)
rb.clicked.connect(self._update_button_text)
radio_layout.addWidget(rb)
if not self.button_group.buttons():
rb.setChecked(True)
self.button_group.addButton(rb)
self.ignore_solvent_button = QCheckBox("Ignore solvent")
self.ignore_solvent_button.setChecked(True)
add_col_layout.addWidget(self.ignore_solvent_button,
1,
0,
1,
2,
alignment=Qt.AlignCenter)
from PyQt5.QtWidgets import QDialogButtonBox as qbbox
bbox = qbbox(qbbox.Ok | qbbox.Cancel | qbbox.Help)
bbox.accepted.connect(self._apply_rotamer)
bbox.rejected.connect(self.tool_window.destroy)
from chimerax.core.commands import run
bbox.helpRequested.connect(
lambda run=run, ses=self.session: run(ses, "help " + self.help))
layout.addWidget(bbox)
self.tool_window.manage(placement=None)
def delete(self, from_mgr=False):
for handler in self.handlers:
handler.remove()
self.subdialogs.clear()
self.opt_columns.clear()
if not from_mgr:
self.mgr.destroy()
super().delete()
@classmethod
def restore_snapshot(cls, session, data):
inst = super().restore_snapshot(session, data['ToolInstance'])
lib_display_name = data['lib_display_name']
for lib_name in session.rotamers.library_names(installed_only=True):
lib = session.rotamers.library(lib_name)
if lib.display_name == lib_display_name:
break
else:
raise RuntimeError(
"Cannot restore Rotamers tool because %s rotamer library is not installed"
% lib_display_name)
inst.finalize_init(data['mgr'],
data['res_type'],
lib_name,
table_info=data['table info'])
return inst
def take_snapshot(self, session, flags):
import sys
data = {
'ToolInstance':
ToolInstance.take_snapshot(self, session, flags),
'mgr':
self.mgr,
'res_type':
self.res_type,
'lib_display_name':
session.rotamers.library(self.rot_lib).display_name,
'table info': (self.table.session_info(),
[(col_type, c.title, c.data_fetch, c.display_format)
for col_type, c in self.opt_columns.items()])
}
return data
def _apply_rotamer(self):
rots = self.table.selected
if not rots:
if self.button_group.checkedButton().text() in self.opt_columns:
raise UserError("No rotamers selected")
else:
raise UserError(
"No rotamers selected. Click the 'Calculate' button (not 'OK') to"
" add a column to the table.")
rot_nums = [r.id[-1] for r in rots]
from chimerax.core.commands import run
cmd = "swapaa %s %s criteria %s rotLib %s" % (
self.mgr.base_residue.string(style="command"),
self.res_type,
",".join(["%d" % rn for rn in rot_nums]),
self.rot_lib,
)
if self.retain_side_chain:
cmd += " retain %s" % str(
self.retain_side_chain.isChecked()).lower()
run(self.session, cmd)
self.delete()
def _eval_vol(self, vol):
AtomicStructure.register_attr(self.session,
"sum_density",
self.registerer,
attr_type=float)
for rot in self.mgr.rotamers:
values = vol.interpolated_values(rot.atoms.coords,
point_xform=rot.scene_position)
total = 0
for a, val in zip(rot.atoms, values):
# 'is_side_chain' only works for actual polymers
if a.name not in a.residue.aa_max_backbone_names:
total += val
rot.sum_density = total
sd_type = "Density"
if sd_type in self.opt_columns:
self.table.update_column(self.opt_columns[sd_type], data=True)
else:
self.opt_columns[sd_type] = self.table.add_column(sd_type,
"sum_density",
format="%g")
def _fewer_rots_cb(self, trig_name, mgr):
self.rot_table.set_data(self.mgr.rotamers)
def _mgr_destroyed_cb(self, trig_name, mgr):
self.delete(from_mgr=True)
def _selection_change(self, selected, deselected):
if self.table.selected:
display = set(self.table.selected)
else:
display = set(self.mgr.rotamers)
for rot in self.mgr.rotamers:
rot.display = rot in display
def _process_subdialog(self, sd_type):
sd = self.subdialogs[sd_type]
from chimerax.core.commands import run
if sd_type == "H-Bonds":
cmd_name, spec, args = sd.hbonds_gui.get_command()
res = self.mgr.base_residue
base_spec = "#!%s & ~%s" % (res.structure.id_string,
res.string(style="command"))
if self.ignore_solvent_button.isChecked():
base_spec += " & ~solvent"
hbs = run(
self.session, "%s %s %s restrict #%s & ~@c,ca,n" %
(cmd_name, base_spec, args, self.mgr.group.id_string))
AtomicStructure.register_attr(self.session,
"num_hbonds",
self.registerer,
attr_type=int)
for rotamer in self.mgr.rotamers:
rotamer.num_hbonds = 0
for d, a in hbs:
if d.structure == res.structure:
a.structure.num_hbonds += 1
else:
d.structure.num_hbonds += 1
if sd_type in self.opt_columns:
self.table.update_column(self.opt_columns[sd_type], data=True)
else:
self.opt_columns[sd_type] = self.table.add_column(sd_type,
"num_hbonds",
format="%d")
elif sd_type == "Clashes":
cmd_name, spec, args = sd.clashes_gui.get_command()
res = self.mgr.base_residue
base_spec = "#!%s & ~%s" % (res.structure.id_string,
res.string(style="command"))
if self.ignore_solvent_button.isChecked():
base_spec += " & ~solvent"
clashes = run(
self.session, "%s %s %s restrict #%s & ~@c,ca,n" %
(cmd_name, base_spec, args, self.mgr.group.id_string))
AtomicStructure.register_attr(self.session,
"num_clashes",
self.registerer,
attr_type=int)
for rotamer in self.mgr.rotamers:
rotamer.num_clashes = 0
for a, clashing in clashes.items():
if a.structure != res.structure:
a.structure.num_clashes += len(clashing)
if sd_type in self.opt_columns:
self.table.update_column(self.opt_columns[sd_type], data=True)
else:
self.opt_columns[sd_type] = self.table.add_column(
sd_type, "num_clashes", format="%d")
else: # Density
vol = sd.vol_list.value
if not vol:
return
self._eval_vol(vol)
self._update_button_text()
def _show_subdialog(self, sd_type):
if sd_type == "Density":
from chimerax.map import Volume
volumes = [m for m in self.session.models if isinstance(m, Volume)]
if not volumes:
raise UserError("Must open a volume/map file first!")
if len(volumes) == 1:
self._eval_vol(volumes[0])
return
if sd_type not in self.subdialogs:
self.subdialogs[
sd_type] = sd = self.tool_window.create_child_window(
"Add %s Column" % sd_type)
from PyQt5.QtWidgets import QVBoxLayout, QDialogButtonBox as qbbox
layout = QVBoxLayout()
sd.ui_area.setLayout(layout)
if sd_type == "H-Bonds":
from chimerax.hbonds.gui import HBondsGUI
sd.hbonds_gui = HBondsGUI(self.session,
settings_name="rotamers",
reveal=True,
show_inter_model=False,
show_intra_model=False,
show_intra_mol=False,
show_intra_res=False,
show_model_restrict=False,
show_bond_restrict=False,
show_save_file=False)
layout.addWidget(sd.hbonds_gui)
elif sd_type == "Clashes":
from chimerax.clashes.gui import ClashesGUI
sd.clashes_gui = ClashesGUI(self.session,
False,
settings_name="rotamers",
radius=0.075,
show_restrict=False,
show_bond_separation=False,
show_res_separation=False,
show_inter_model=False,
show_intra_model=False,
show_intra_res=False,
show_intra_mol=False,
show_attr_name=False,
show_set_attrs=False,
show_checking_frequency=False,
restrict="cross",
bond_separation=0,
reveal=True,
show_save_file=False)
layout.addWidget(sd.clashes_gui)
else: # Density
from chimerax.ui.widgets import ModelListWidget
from PyQt5.QtWidgets import QFormLayout
density_layout = QFormLayout()
layout.addLayout(density_layout)
sd.vol_list = ModelListWidget(self.session,
selection_mode='single',
class_filter=Volume)
density_layout.addRow("Select density:", sd.vol_list)
bbox = qbbox(qbbox.Ok | qbbox.Close | qbbox.Help)
bbox.accepted.connect(
lambda sdt=sd_type: self._process_subdialog(sdt))
bbox.accepted.connect(lambda sd=sd: setattr(sd, 'shown', False))
bbox.rejected.connect(lambda sd=sd: setattr(sd, 'shown', False))
layout.addWidget(bbox)
sd.manage(placement=None)
else:
self.subdialogs[sd_type].title = "Update %s Column" % sd_type
self.subdialogs[sd_type].shown = True
def _update_button_text(self):
cur_choice = self.button_group.checkedButton().text()
if cur_choice.startswith("Density"):
self.ignore_solvent_button.hide()
else:
self.ignore_solvent_button.show()
def __init__(self, parent=None, button_func=None, params=None):
super().__init__(parent, 'Data check', params)
self.button_func = button_func
path = os.path.abspath(os.path.dirname(__file__)) + '/static/'
# nr = min(5, data.shape[0])
nr = len(self.params.data5)
if params.lang == 'jp':
text = ('データの読み込み結果（先頭{n}行）を以下に示します．\n'
'データを正しく読み込めていることを確認してください．'.format(n=nr))
self.set_paragraph(
'データ読み込み結果の確認', text=text)
else:
text = ('First {n} rows of your data are shown below.\n'
'Confirm that the data was read correctly.'.format(n=nr))
self.set_paragraph(
'Check data', text=text)
table = NonScrollTable(self.inner)
table.setRowCount(nr)
table.setColumnCount(len(self.params.columns))
table.setHorizontalHeaderLabels(self.params.columns)
for r in range(nr):
for c in range(len(self.params.columns)):
item = QTableWidgetItem(str(self.params.data5.iat[r, c]))
item.setFlags(Qt.ItemIsEnabled)
table.setItem(r, c, item)
table.setNonScroll()
self.vbox.addWidget(table)
# Text for type checking and objective variable setting
path1 = path + 'categorical'
text = self.get_text(path1)
if self.params.lang == 'en':
self.set_paragraph(
'Check type of variables and set objective variable',
text=text)
else:
self.set_paragraph('変数タイプの確認と目的変数の設定', text=text)
# htable = QTableWidget(self.inner)
htable = NonScrollTable(self.inner)
htable.setRowCount(len(self.params.columns))
htable.setColumnCount(4)
htable.setHorizontalHeaderLabels(
['columns', 'categorical', 'numerical', 'target'])
self.lst_cat = []
self.lst_num = []
self.lst_obj = []
self.obj_group = QButtonGroup(self.inner)
for c in range(len(self.params.columns)):
# col 1
item = QTableWidgetItem(self.params.columns[c])
item.setFlags(Qt.ItemIsEnabled)
htable.setItem(c, 0, item)
group = QButtonGroup(self.inner)
# col 2
htable.setCellWidget(
c, 1,
self.__make_cell(c, 'cat', self.params.col_types[c],
self.params.col_types_def[c]))
group.addButton(self.lst_cat[-1])
# col 3
htable.setCellWidget(
c, 2,
self.__make_cell(c, 'num', self.params.col_types[c],
self.params.col_types_def[c]))
group.addButton(self.lst_num[-1])
# col 4
htable.setCellWidget(
c, 3,
self.__make_cell(c, 'obj', self.params.col_types[c],
self.params.col_types_def[c]))
self.obj_group.addButton(self.lst_obj[-1])
self.obj_group.setId(self.lst_obj[-1], c)
htable.setNonScroll()
self.vbox.addWidget(htable)
if self.params.lang == 'jp':
self.txt_cnf = ('<font color="red">目的変数を１つ選択し，'
'targetの列にチェックをいれてください。')
if self.params.task.lower() == 'classification':
self.txt_cnf += '<br>目的変数はカテゴリ変数である必要があります。</font>'
else:
self.txt_cnf += '<br>目的変数は量的変数である必要があります。</font>'
else:
self.txt_cnf = ('<font color="red">Select one variable as target variable,'
'then set the column of "target" of the variable checked.')
if self.params.task.lower() == 'classification':
self.txt_cnf += '<br>Target variable must be a categorical variable.</font>'
else:
self.txt_cnf += '<br>Target variable must be a numerical variable.</font>'
self.lbl_cnf = QLabel(self.txt_cnf, self.inner)
self.vbox.addWidget(self.lbl_cnf)
self.vbox.addStretch(1)
self.btn = QPushButton('Next', self.inner)
self.btn.setStyleSheet('QPushButton{font: bold; font-size: 15pt; background-color: white;};')
if self.params.lang == 'en':
self.btn.clicked.connect(lambda: self.button_func('Overfitting'))
else:
self.btn.clicked.connect(lambda: self.button_func('過学習'))
if self.obj_group.checkedButton() is None:
self.btn.setEnabled(False)
else:
self.btn.setEnabled(True)
self.vbox.addWidget(self.btn)
def initUI(self):
vbox = QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
measures = self.model.curr_piece.measures
measureGrid = QGridLayout()
for m in range(len(measures)):
measureBtn = QPushButton(f"Measure {m + 1}", self)
measureBtn.setObjectName('measure-btn')
measureBtn.clicked.connect(partial(self.playMeasure, m))
measureGrid.addWidget(measureBtn,
0,
m,
1,
1,
alignment=QtCore.Qt.AlignCenter)
ratingWidget = QWidget()
ratingLayout = QHBoxLayout()
ratingLayout.setContentsMargins(50, 0, 50, 0)
ratingLayout.setSpacing(20)
button_group = QButtonGroup(ratingLayout)
for i in range(5):
ratingBtn = QRadioButton()
ratingBtn.toggled.connect(
partial(self.setMeasureRating, self.model.curr_piece_idx,
m, i + 1))
if measures[m].user_score == i + 1:
print(measures[m].user_score)
ratingBtn.setChecked(True)
ratingBtn.setObjectName('rating-btn')
ratingBtn.setStyleSheet(f"""
QRadioButton {{
background-color: {self.btn_colors[i]};
border: 8px solid {self.btn_colors[i]};
}}
QRadioButton::indicator::unchecked {{
background-color: {self.btn_colors[i]}
border: none;
}}
""")
button_group.addButton(ratingBtn)
ratingLayout.addWidget(ratingBtn)
ratingWidget.setLayout(ratingLayout)
measureGrid.addWidget(ratingWidget, 1, m)
pcb = PlayControlBar(self.model.parent.toNextPiece,
self.model.parent.play,
self.model.parent.toPreviousPiece)
vbox.addWidget(self.titleLabel, 1, QtCore.Qt.AlignCenter)
vbox.addLayout(measureGrid, 4)
vbox.addLayout(self.initFullBox(), 1)
vbox.addWidget(self.fitnessLabel)
vbox.addWidget(pcb, 0.9)
self.setLayout(vbox)
