class DoubleSpin(QWidget):
#a custom widget containing 2 QSpinBoxes in a row
#is used for pair user input (like x,y or width, height)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
layout = QHBoxLayout()
self.sbx = QSpinBox()
self.sby = QSpinBox()
self.sbx.setRange(0, 1000)
self.sby.setRange(0, 1000)
lb = QLabel('x')
lb.setSizePolicy(Qt.QSizePolicy.Minimum, Qt.QSizePolicy.Minimum)
layout.addWidget(lb)
self.sbx.setSizePolicy(Qt.QSizePolicy.Maximum, Qt.QSizePolicy.Maximum)
layout.addWidget(self.sbx)
lby = QLabel('y')
lby.setSizePolicy(Qt.QSizePolicy.Minimum, Qt.QSizePolicy.Minimum)
layout.addWidget(lby)
layout.setAlignment(Qt.Qt.AlignLeft)
layout.addWidget(self.sby)
self.setLayout(layout)
def setX(self, x):
self.sbx.setValue(x)
def setY(self, y):
self.sby.setValue(y)
def getValues(self):
return (self.sbx.value(), self.sby.value())
class GenerateLabelsDialog(QDialog):
#Generate labels dialog class
def __init__(self, p=None):
QDialog.__init__(self, p)
self.setWindowTitle("Generate page layout...")
self.layout = QFormLayout()
self.numberOfLabelsSpinBox = QSpinBox()
self.numberOfLabelsSpinBox.setRange(1, 200)
self.numberOfLabelsSpinBox.setValue(
generate_settings['defaultNumberOfLabels'])
self.layout.addRow("Number of labels", self.numberOfLabelsSpinBox)
self.firstLabelArticleNumberSB = QSpinBox()
self.firstLabelArticleNumberSB.setRange(0, 9999)
self.firstLabelArticleNumberSB.setValue(
generate_settings['firstLabelArticleNumber'])
self.layout.addRow("First label article number",
self.firstLabelArticleNumberSB)
self.weekNrYearLE = QLineEdit()
self.weekNrYearLE.setText(generate_settings['weekNrYear'])
self.layout.addRow("Week nr/ year", self.weekNrYearLE)
self.lotNameLE = QLineEdit()
self.lotNameLE.setText(generate_settings['lotName'])
self.layout.addRow("Lot", self.lotNameLE)
self.generatePB = QPushButton("Generate")
self.generatePB.clicked.connect(self.onGenerate)
self.layout.addRow("", self.generatePB)
self.cancelPB = QPushButton("Cancel")
self.cancelPB.clicked.connect(self.close)
self.layout.addRow("", self.cancelPB)
self.setLayout(self.layout)
def onGenerate(self):
generate_settings[
'defaultNumberOfLabels'] = self.numberOfLabelsSpinBox.value()
generate_settings[
'firstLabelArticleNumber'] = self.firstLabelArticleNumberSB.value(
)
generate_settings['weekNrYear'] = self.weekNrYearLE.text()
generate_settings['lotName'] = self.lotNameLE.text()
self.accept()
class TabMNConf_gui(QWidget):
def __init__(self, masternode_alias=None, *args, **kwargs):
QWidget.__init__(self)
self.initConfigForm(masternode_alias)
###-- Compose tab2 layout
mainVertical2 = QVBoxLayout()
mainVertical2.setSpacing(10)
mainVertical2.addWidget(self.configForm)
vBox = QVBoxLayout()
vBox.addStretch(1)
mainVertical2.addLayout(vBox)
mainVertical2.addLayout(self.footer)
self.setLayout(mainVertical2)
def clearConfigForm(self):
self.testnetCheck.setChecked(False)
self.edt_name.setText('')
self.edt_masternodeIp.setText('')
self.edt_masternodePort.setValue(51472)
self.edt_mnPrivKey.setText('')
self.edt_hwAccount.setValue(0)
self.edt_address.setText('')
self.edt_spath.setValue(0)
self.edt_pubKey.setText('')
self.edt_txid.setText('')
self.edt_txidn.setValue(0)
self.configForm.setTitle('New Masternode')
def fillConfigForm(self, masternode):
self.edt_name.setText(masternode['name'])
self.edt_masternodeIp.setText(masternode['ip'])
self.edt_masternodePort.setValue(masternode['port'])
self.edt_mnPrivKey.setText(masternode['mnPrivKey'])
self.edt_hwAccount.setValue(masternode['hwAcc'])
if masternode['isTestnet'] == 1:
self.testnetCheck.setChecked(True)
else:
self.testnetCheck.setChecked(False)
self.edt_address.setText(masternode['collateral'].get('address'))
self.edt_spath.setValue(masternode['collateral'].get('spath'))
self.edt_pubKey.setText(masternode['collateral'].get('pubKey'))
self.edt_txid.setText(masternode['collateral'].get('txid'))
self.edt_txidn.setValue(masternode['collateral'].get('txidn'))
self.configForm.setTitle("Edit Masternode")
def initConfigForm(self, masternode_alias=None):
self.configForm = QGroupBox()
if not masternode_alias:
self.configForm.setTitle("New Masternode")
else:
self.configForm.setTitle("Edit Masternode [%s]" % masternode_alias)
layout = QFormLayout()
layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
layout.setContentsMargins(10, 20, 10, 10)
layout.setSpacing(13)
##--- ROW 1
self.edt_name = QLineEdit()
self.edt_name.setToolTip(
"masternode Alias.\n-- example: My Masternode 1")
layout.addRow(QLabel("Name"), self.edt_name)
##--- ROW 2
line1 = QHBoxLayout()
self.edt_masternodeIp = QLineEdit()
self.edt_masternodeIp.setToolTip(
"masternode IP address\n-- example [IPv4] 88.172.23.1\n-- example [IPv6] 2001:db8:85a3::8a2e:370:7334"
)
line1.addWidget(self.edt_masternodeIp)
line1.addWidget(QLabel("IP Port"))
self.edt_masternodePort = QSpinBox()
self.edt_masternodePort.setRange(1, 65535)
self.edt_masternodePort.setValue(51472)
self.edt_masternodePort.setToolTip(
"remote masternode tcp port \n-- example: 51472")
self.edt_masternodePort.setFixedWidth(180)
line1.addWidget(self.edt_masternodePort)
layout.addRow(QLabel("IP Address"), line1)
##--- ROW 3
self.edt_mnPrivKey = QLineEdit()
self.edt_mnPrivKey.setToolTip(
"masternode private key \n-- output of 'masternode genkey' command"
)
self.btn_genKey = QPushButton("Generate")
self.btn_genKey.setToolTip(
"generate masternode privKey from hardware wallet")
hBox2 = QHBoxLayout()
hBox2.addWidget(self.edt_mnPrivKey)
hBox2.addWidget(self.btn_genKey)
## Testnet check
self.testnetCheck = QCheckBox()
self.testnetCheck.setToolTip("check for TESTNET masternode setup")
hBox2.addWidget(QLabel("testnet"))
hBox2.addWidget(self.testnetCheck)
layout.addRow(QLabel("MN Priv Key"), hBox2)
##--- ROW 4/5
layout.addRow(QFrame())
layout.addRow(QLabel("<em>Masternode Collateral</em>"))
hBox3 = QHBoxLayout()
self.edt_hwAccount = QSpinBox()
self.edt_hwAccount.setFixedWidth(50)
self.edt_hwAccount.setToolTip(
"account number of the hardware wallet.\nIf unsure put 0")
self.edt_hwAccount.setValue(0)
hBox3.addWidget(self.edt_hwAccount)
hBox3.addWidget(QLabel("PIVX Address"))
self.edt_address = QLineEdit()
self.edt_address.setToolTip("the address containing 10000 PIV")
self.edt_spath = QSpinBox()
self.edt_spath.setToolTip("BIP44 spath for the address")
self.edt_spath.setFixedWidth(75)
self.edt_spath.setValue(0)
self.btn_spathToAddress = QPushButton("<<")
self.btn_spathToAddress.setToolTip(
"find address and public key of given account/spath_id")
self.btn_addressToSpath = QPushButton(">>")
self.btn_addressToSpath.setToolTip(
"find spath_id and public key of given account/address")
hBox3.addWidget(self.edt_address)
hBox3.addWidget(self.btn_spathToAddress)
hBox3.addWidget(self.btn_addressToSpath)
hBox3.addWidget(QLabel("spath_id"))
hBox3.addWidget(self.edt_spath)
layout.addRow(QLabel("Account HW"), hBox3)
##--- ROW 6
self.edt_pubKey = QLineEdit()
self.edt_pubKey.setToolTip("public key corresponding to address")
self.edt_pubKey.setEnabled(False)
layout.addRow(QLabel("Public Key"), self.edt_pubKey)
##--- ROW 7
hBox5 = QHBoxLayout()
self.btn_findTxid = QPushButton("Lookup")
self.btn_findTxid.setToolTip("look for txid and txidn on explorer")
hBox5.addWidget(self.btn_findTxid)
hBox5.addWidget(QLabel("/"))
self.btn_editTxid = QPushButton("Edit")
self.btn_editTxid.setToolTip("edit txid and txidn manually")
hBox5.addWidget(self.btn_editTxid)
hBox5.addWidget(QLabel("txid"))
self.edt_txid = QLineEdit()
self.edt_txid.setToolTip("txid for the collateral")
self.edt_txid.setEnabled(False)
hBox5.addWidget(self.edt_txid)
hBox5.addWidget(QLabel("txidn"))
self.edt_txidn = QSpinBox()
self.edt_txidn.setFixedWidth(50)
self.edt_txidn.setToolTip("txidn for the collateral")
self.edt_txidn.setEnabled(False)
hBox5.addWidget(self.edt_txidn)
layout.addRow(QLabel("Transaction"), hBox5)
##--- Set Layout
self.configForm.setLayout(layout)
##--- Footer
self.footer = QHBoxLayout()
self.footer.addStretch(1)
self.btn_cancelMNConf = QPushButton('Cancel')
self.btn_cancelMNConf.setToolTip(
"cancel changes and go back to main list")
self.footer.addWidget(self.btn_cancelMNConf)
self.btn_saveMNConf = QPushButton('Save')
self.btn_saveMNConf.setToolTip(
"save configuration and go back to main list")
self.footer.addWidget(self.btn_saveMNConf)
class AddEmptyBookDialog(QDialog):
def __init__(self, parent, db, author, series=None, title=None, dup_title=None):
QDialog.__init__(self, parent)
self.db = db
self.setWindowTitle(_('How many empty books?'))
self._layout = QGridLayout(self)
self.setLayout(self._layout)
self.qty_label = QLabel(_('How many empty books should be added?'))
self._layout.addWidget(self.qty_label, 0, 0, 1, 2)
self.qty_spinbox = QSpinBox(self)
self.qty_spinbox.setRange(1, 10000)
self.qty_spinbox.setValue(1)
self._layout.addWidget(self.qty_spinbox, 1, 0, 1, 2)
self.author_label = QLabel(_('Set the author of the new books to:'))
self._layout.addWidget(self.author_label, 2, 0, 1, 2)
self.authors_combo = EditWithComplete(self)
self.authors_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.authors_combo.setEditable(True)
self._layout.addWidget(self.authors_combo, 3, 0, 1, 1)
self.initialize_authors(db, author)
self.clear_button = QToolButton(self)
self.clear_button.setIcon(QIcon(I('trash.png')))
self.clear_button.setToolTip(_('Reset author to Unknown'))
self.clear_button.clicked.connect(self.reset_author)
self._layout.addWidget(self.clear_button, 3, 1, 1, 1)
self.series_label = QLabel(_('Set the series of the new books to:'))
self._layout.addWidget(self.series_label, 4, 0, 1, 2)
self.series_combo = EditWithComplete(self)
self.series_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.series_combo.setEditable(True)
self._layout.addWidget(self.series_combo, 5, 0, 1, 1)
self.initialize_series(db, series)
self.sclear_button = QToolButton(self)
self.sclear_button.setIcon(QIcon(I('trash.png')))
self.sclear_button.setToolTip(_('Reset series'))
self.sclear_button.clicked.connect(self.reset_series)
self._layout.addWidget(self.sclear_button, 5, 1, 1, 1)
self.title_label = QLabel(_('Set the title of the new books to:'))
self._layout.addWidget(self.title_label, 6, 0, 1, 2)
self.title_edit = QLineEdit(self)
self.title_edit.setText(title or '')
self._layout.addWidget(self.title_edit, 7, 0, 1, 1)
self.tclear_button = QToolButton(self)
self.tclear_button.setIcon(QIcon(I('trash.png')))
self.tclear_button.setToolTip(_('Reset title'))
self.tclear_button.clicked.connect(self.title_edit.clear)
self._layout.addWidget(self.tclear_button, 7, 1, 1, 1)
self.format_label = QLabel(_('Also create an empty e-book in format:'))
self._layout.addWidget(self.format_label, 8, 0, 1, 2)
c = self.format_value = QComboBox(self)
from calibre.ebooks.oeb.polish.create import valid_empty_formats
possible_formats = [''] + sorted(x.upper() for x in valid_empty_formats)
c.addItems(possible_formats)
c.setToolTip(_('Also create an empty book format file that you can subsequently edit'))
if gprefs.get('create_empty_epub_file', False):
# Migration of the check box
gprefs.set('create_empty_format_file', 'epub')
del gprefs['create_empty_epub_file']
use_format = gprefs.get('create_empty_format_file', '').upper()
try:
c.setCurrentIndex(possible_formats.index(use_format))
except Exception:
pass
self._layout.addWidget(c, 9, 0, 1, 1)
self.copy_formats = cf = QCheckBox(_('Also copy book &formats when duplicating a book'), self)
cf.setToolTip(_(
'Also copy all e-book files into the newly created duplicate'
' books.'))
cf.setChecked(gprefs.get('create_empty_copy_dup_formats', False))
self._layout.addWidget(cf, 10, 0, 1, -1)
button_box = self.bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self._layout.addWidget(button_box, 11, 0, 1, -1)
if dup_title:
self.dup_button = b = button_box.addButton(_('&Duplicate current book'), button_box.ActionRole)
b.clicked.connect(self.do_duplicate_book)
b.setIcon(QIcon(I('edit-copy.png')))
b.setToolTip(_(
'Make the new empty book records exact duplicates\n'
'of the current book "%s", with all metadata identical'
) % dup_title)
self.resize(self.sizeHint())
self.duplicate_current_book = False
def do_duplicate_book(self):
self.duplicate_current_book = True
self.accept()
def accept(self):
self.save_settings()
return QDialog.accept(self)
def save_settings(self):
gprefs['create_empty_format_file'] = self.format_value.currentText().lower()
gprefs['create_empty_copy_dup_formats'] = self.copy_formats.isChecked()
def reject(self):
self.save_settings()
return QDialog.reject(self)
def reset_author(self, *args):
self.authors_combo.setEditText(_('Unknown'))
def reset_series(self):
self.series_combo.setEditText('')
def initialize_authors(self, db, author):
au = author
if not au:
au = _('Unknown')
self.authors_combo.show_initial_value(au.replace('|', ','))
self.authors_combo.set_separator('&')
self.authors_combo.set_space_before_sep(True)
self.authors_combo.set_add_separator(tweaks['authors_completer_append_separator'])
self.authors_combo.update_items_cache(db.all_author_names())
def initialize_series(self, db, series):
self.series_combo.show_initial_value(series or '')
self.series_combo.update_items_cache(db.all_series_names())
self.series_combo.set_separator(None)
@property
def qty_to_add(self):
return self.qty_spinbox.value()
@property
def selected_authors(self):
return string_to_authors(unicode_type(self.authors_combo.text()))
@property
def selected_series(self):
return unicode_type(self.series_combo.text())
@property
def selected_title(self):
return self.title_edit.text().strip()
class AddEmptyBookDialog(QDialog):
def __init__(self, parent, db, author, series=None, title=None):
QDialog.__init__(self, parent)
self.db = db
self.setWindowTitle(_('How many empty books?'))
self._layout = QGridLayout(self)
self.setLayout(self._layout)
self.qty_label = QLabel(_('How many empty books should be added?'))
self._layout.addWidget(self.qty_label, 0, 0, 1, 2)
self.qty_spinbox = QSpinBox(self)
self.qty_spinbox.setRange(1, 10000)
self.qty_spinbox.setValue(1)
self._layout.addWidget(self.qty_spinbox, 1, 0, 1, 2)
self.author_label = QLabel(_('Set the author of the new books to:'))
self._layout.addWidget(self.author_label, 2, 0, 1, 2)
self.authors_combo = EditWithComplete(self)
self.authors_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.authors_combo.setEditable(True)
self._layout.addWidget(self.authors_combo, 3, 0, 1, 1)
self.initialize_authors(db, author)
self.clear_button = QToolButton(self)
self.clear_button.setIcon(QIcon(I('trash.png')))
self.clear_button.setToolTip(_('Reset author to Unknown'))
self.clear_button.clicked.connect(self.reset_author)
self._layout.addWidget(self.clear_button, 3, 1, 1, 1)
self.series_label = QLabel(_('Set the series of the new books to:'))
self._layout.addWidget(self.series_label, 4, 0, 1, 2)
self.series_combo = EditWithComplete(self)
self.series_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.series_combo.setEditable(True)
self._layout.addWidget(self.series_combo, 5, 0, 1, 1)
self.initialize_series(db, series)
self.sclear_button = QToolButton(self)
self.sclear_button.setIcon(QIcon(I('trash.png')))
self.sclear_button.setToolTip(_('Reset series'))
self.sclear_button.clicked.connect(self.reset_series)
self._layout.addWidget(self.sclear_button, 5, 1, 1, 1)
self.title_label = QLabel(_('Set the title of the new books to:'))
self._layout.addWidget(self.title_label, 6, 0, 1, 2)
self.title_edit = QLineEdit(self)
self.title_edit.setText(title or '')
self._layout.addWidget(self.title_edit, 7, 0, 1, 1)
self.tclear_button = QToolButton(self)
self.tclear_button.setIcon(QIcon(I('trash.png')))
self.tclear_button.setToolTip(_('Reset title'))
self.tclear_button.clicked.connect(self.title_edit.clear)
self._layout.addWidget(self.tclear_button, 7, 1, 1, 1)
self.format_label = QLabel(_('Also create an empty ebook in format:'))
self._layout.addWidget(self.format_label, 8, 0, 1, 2)
c = self.format_value = QComboBox(self)
from calibre.ebooks.oeb.polish.create import valid_empty_formats
possible_formats = [''] + sorted(x.upper() for x in valid_empty_formats)
c.addItems(possible_formats)
c.setToolTip(_('Also create an empty book format file that you can subsequently edit'))
if gprefs.get('create_empty_epub_file', False):
# Migration of the check box
gprefs.set('create_empty_format_file', 'epub')
del gprefs['create_empty_epub_file']
use_format = gprefs.get('create_empty_format_file', '').upper()
try:
c.setCurrentIndex(possible_formats.index(use_format))
except Exception:
pass
self._layout.addWidget(c, 9, 0, 1, 1)
button_box = self.bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self._layout.addWidget(button_box, 10, 0, 1, -1)
self.resize(self.sizeHint())
def accept(self):
gprefs['create_empty_format_file'] = self.format_value.currentText().lower()
return QDialog.accept(self)
def reset_author(self, *args):
self.authors_combo.setEditText(_('Unknown'))
def reset_series(self):
self.series_combo.setEditText('')
def initialize_authors(self, db, author):
au = author
if not au:
au = _('Unknown')
self.authors_combo.show_initial_value(au.replace('|', ','))
self.authors_combo.set_separator('&')
self.authors_combo.set_space_before_sep(True)
self.authors_combo.set_add_separator(tweaks['authors_completer_append_separator'])
self.authors_combo.update_items_cache(db.all_author_names())
def initialize_series(self, db, series):
self.series_combo.show_initial_value(series or '')
self.series_combo.update_items_cache(db.all_series_names())
self.series_combo.set_separator(None)
@property
def qty_to_add(self):
return self.qty_spinbox.value()
@property
def selected_authors(self):
return string_to_authors(unicode(self.authors_combo.text()))
@property
def selected_series(self):
return unicode(self.series_combo.text())
@property
def selected_title(self):
return self.title_edit.text().strip()
class AddEmptyBookDialog(QDialog):
def __init__(self, parent, db, author, series=None):
QDialog.__init__(self, parent)
self.db = db
self.setWindowTitle(_('How many empty books?'))
self._layout = QGridLayout(self)
self.setLayout(self._layout)
self.qty_label = QLabel(_('How many empty books should be added?'))
self._layout.addWidget(self.qty_label, 0, 0, 1, 2)
self.qty_spinbox = QSpinBox(self)
self.qty_spinbox.setRange(1, 10000)
self.qty_spinbox.setValue(1)
self._layout.addWidget(self.qty_spinbox, 1, 0, 1, 2)
self.author_label = QLabel(_('Set the author of the new books to:'))
self._layout.addWidget(self.author_label, 2, 0, 1, 2)
self.authors_combo = EditWithComplete(self)
self.authors_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.authors_combo.setEditable(True)
self._layout.addWidget(self.authors_combo, 3, 0, 1, 1)
self.initialize_authors(db, author)
self.clear_button = QToolButton(self)
self.clear_button.setIcon(QIcon(I('trash.png')))
self.clear_button.setToolTip(_('Reset author to Unknown'))
self.clear_button.clicked.connect(self.reset_author)
self._layout.addWidget(self.clear_button, 3, 1, 1, 1)
self.series_label = QLabel(_('Set the series of the new books to:'))
self._layout.addWidget(self.series_label, 4, 0, 1, 2)
self.series_combo = EditWithComplete(self)
self.authors_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.series_combo.setEditable(True)
self._layout.addWidget(self.series_combo, 5, 0, 1, 1)
self.initialize_series(db, series)
self.sclear_button = QToolButton(self)
self.sclear_button.setIcon(QIcon(I('trash.png')))
self.sclear_button.setToolTip(_('Reset series'))
self.sclear_button.clicked.connect(self.reset_series)
self._layout.addWidget(self.sclear_button, 5, 1, 1, 1)
self.create_epub = c = QCheckBox(_('Create an empty EPUB file as well'))
c.setChecked(gprefs.get('create_empty_epub_file', False))
c.setToolTip(_('Also create an empty EPUB file that you can subsequently edit'))
self._layout.addWidget(c, 6, 0, 1, -1)
button_box = self.bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self._layout.addWidget(button_box, 7, 0, 1, -1)
self.resize(self.sizeHint())
def accept(self):
oval = gprefs.get('create_empty_epub_file', False)
if self.create_epub.isChecked() != oval:
gprefs['create_empty_epub_file'] = self.create_epub.isChecked()
return QDialog.accept(self)
def reset_author(self, *args):
self.authors_combo.setEditText(_('Unknown'))
def reset_series(self):
self.series_combo.setEditText('')
def initialize_authors(self, db, author):
au = author
if not au:
au = _('Unknown')
self.authors_combo.show_initial_value(au.replace('|', ','))
self.authors_combo.set_separator('&')
self.authors_combo.set_space_before_sep(True)
self.authors_combo.set_add_separator(tweaks['authors_completer_append_separator'])
self.authors_combo.update_items_cache(db.all_author_names())
def initialize_series(self, db, series):
self.series_combo.show_initial_value(series or '')
self.series_combo.update_items_cache(db.all_series_names())
self.series_combo.set_separator(None)
@property
def qty_to_add(self):
return self.qty_spinbox.value()
@property
def selected_authors(self):
return string_to_authors(unicode(self.authors_combo.text()))
@property
def selected_series(self):
return unicode(self.series_combo.text())
class AddEmptyBookDialog(QDialog):
def __init__(self, parent, db, author, series=None):
QDialog.__init__(self, parent)
self.db = db
self.setWindowTitle(_('How many empty books?'))
self._layout = QGridLayout(self)
self.setLayout(self._layout)
self.qty_label = QLabel(_('How many empty books should be added?'))
self._layout.addWidget(self.qty_label, 0, 0, 1, 2)
self.qty_spinbox = QSpinBox(self)
self.qty_spinbox.setRange(1, 10000)
self.qty_spinbox.setValue(1)
self._layout.addWidget(self.qty_spinbox, 1, 0, 1, 2)
self.author_label = QLabel(_('Set the author of the new books to:'))
self._layout.addWidget(self.author_label, 2, 0, 1, 2)
self.authors_combo = EditWithComplete(self)
self.authors_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.authors_combo.setEditable(True)
self._layout.addWidget(self.authors_combo, 3, 0, 1, 1)
self.initialize_authors(db, author)
self.clear_button = QToolButton(self)
self.clear_button.setIcon(QIcon(I('trash.png')))
self.clear_button.setToolTip(_('Reset author to Unknown'))
self.clear_button.clicked.connect(self.reset_author)
self._layout.addWidget(self.clear_button, 3, 1, 1, 1)
self.series_label = QLabel(_('Set the series of the new books to:'))
self._layout.addWidget(self.series_label, 4, 0, 1, 2)
self.series_combo = EditWithComplete(self)
self.authors_combo.setSizeAdjustPolicy(
self.authors_combo.AdjustToMinimumContentsLengthWithIcon)
self.series_combo.setEditable(True)
self._layout.addWidget(self.series_combo, 5, 0, 1, 1)
self.initialize_series(db, series)
self.sclear_button = QToolButton(self)
self.sclear_button.setIcon(QIcon(I('trash.png')))
self.sclear_button.setToolTip(_('Reset series'))
self.sclear_button.clicked.connect(self.reset_series)
self._layout.addWidget(self.sclear_button, 5, 1, 1, 1)
self.create_epub = c = QCheckBox(
_('Create an empty EPUB file as well'))
c.setChecked(gprefs.get('create_empty_epub_file', False))
c.setToolTip(
_('Also create an empty EPUB file that you can subsequently edit'))
self._layout.addWidget(c, 6, 0, 1, -1)
button_box = self.bb = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
button_box.accepted.connect(self.accept)
button_box.rejected.connect(self.reject)
self._layout.addWidget(button_box, 7, 0, 1, -1)
self.resize(self.sizeHint())
def accept(self):
oval = gprefs.get('create_empty_epub_file', False)
if self.create_epub.isChecked() != oval:
gprefs['create_empty_epub_file'] = self.create_epub.isChecked()
return QDialog.accept(self)
def reset_author(self, *args):
self.authors_combo.setEditText(_('Unknown'))
def reset_series(self):
self.series_combo.setEditText('')
def initialize_authors(self, db, author):
au = author
if not au:
au = _('Unknown')
self.authors_combo.show_initial_value(au.replace('|', ','))
self.authors_combo.set_separator('&')
self.authors_combo.set_space_before_sep(True)
self.authors_combo.set_add_separator(
tweaks['authors_completer_append_separator'])
self.authors_combo.update_items_cache(db.all_author_names())
def initialize_series(self, db, series):
self.series_combo.show_initial_value(series or '')
self.series_combo.update_items_cache(db.all_series_names())
self.series_combo.set_separator(None)
@property
def qty_to_add(self):
return self.qty_spinbox.value()
@property
def selected_authors(self):
return string_to_authors(unicode(self.authors_combo.text()))
@property
def selected_series(self):
return unicode(self.series_combo.text())
class PreferencesDialog(QDialog):
#the user preferences itself
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle('Preferences')
self.resize(600, 240)
layout = QHBoxLayout()
preview = Preview(self)
#Antonio has a problem with the width of Preview
form = QFormLayout()
self.widthSB = QSpinBox()
self.heightSB = QSpinBox()
self.widthSB.setRange(1, 1000)
self.heightSB.setRange(1, 1000)
self.widthSB.setValue(label_size[0])
self.heightSB.setValue(label_size[1])
form.addRow('Width', self.widthSB)
form.addRow('Height', self.heightSB)
self.spacingDS = DoubleSpin()
self.spacingDS.setX(spacing[0])
self.spacingDS.setY(spacing[1])
form.addRow('Spacing', self.spacingDS)
self.offsetDS = DoubleSpin()
self.offsetDS.setX(first_label_offset[0])
self.offsetDS.setY(first_label_offset[1])
form.addRow('Offset', self.offsetDS)
self.p1 = DoubleSpin()
self.p1.setX(item_positions['article'][0])
self.p1.setY(item_positions['article'][1])
form.addRow('p1', self.p1)
self.p2 = DoubleSpin()
self.p2.setX(item_positions['week'][0])
self.p2.setY(item_positions['week'][1])
form.addRow('p2', self.p2)
self.p3 = DoubleSpin()
self.p3.setX(item_positions['lot'][0])
self.p3.setY(item_positions['lot'][1])
form.addRow('p3', self.p3)
self.p4 = DoubleSpin()
self.p4.setX(item_positions['code'][0])
self.p4.setY(item_positions['code'][1])
form.addRow('p4', self.p4)
self.qr_sizeDS = DoubleSpin()
self.qr_sizeDS.setX(qr_size[0])
self.qr_sizeDS.setY(qr_size[1])
form.addRow('QR size', self.qr_sizeDS)
self.alignament_mark = DoubleSpin()
self.alignament_mark.setX(
item_positions['logo']
[0]) #instead of logo, position of alignment_mark is used
self.alignament_mark.setY(item_positions['logo'][1])
form.addRow('Alignment mark', self.alignament_mark)
self.numberofColumnsSB = QSpinBox()
self.numberofColumnsSB.setRange(1, 10)
self.numberofColumnsSB.setValue(n_columns)
form.addRow('Number of columns', self.numberofColumnsSB)
self.numberofRowsSB = QSpinBox()
self.numberofRowsSB.setRange(1, 50)
self.numberofRowsSB.setValue(n_rows_per_page)
form.addRow('Number of rows', self.numberofRowsSB)
self.fontSizeSB = QSpinBox()
self.fontSizeSB.setRange(4, 25)
self.fontSizeSB.setValue(font['size'])
form.addRow('Font size', self.fontSizeSB)
self.frame_visible = QComboBox()
self.frame_visible.addItem('True')
self.frame_visible.addItem('False')
form.addRow('Frame visible?', self.frame_visible)
pbOk = QPushButton('OK')
pbOk.clicked.connect(self.accept)
form.addRow('', pbOk)
pbCancel = QPushButton('Cancel')
pbCancel.clicked.connect(self.reject)
form.addRow('', pbCancel)
layout.addWidget(preview)
layout.addLayout(form)
self.setLayout(layout)
def createGuiCalibration():
gb = QGroupBox("Gui Calibration")
layout = QGridLayout()
label1 = QLabel("Time speed (delay):")
label2 = QLabel("Sine amplitude:")
label3 = QLabel("Pen width:")
label4 = QLabel("Vertical position:")
label5 = QLabel("X axis offset from right:")
timeDelay_sb = QSpinBox()
timeDelay_sb.setRange(2, 20) # actual ms is times 10
timeDelay_sb.setValue(tracker.timer_interval /
10) # value is in multiples of 10 ms
timeDelay_sb.setMaximumWidth(60)
timeDelay_sb.setMinimumHeight(25)
timeDelay_sb.valueChanged.connect(tracker.set_timer_interval)
amplitude_sb = QSpinBox()
amplitude_sb.setRange(20, 300)
amplitude_sb.setValue(tracker.amplitude)
amplitude_sb.setMaximumWidth(60)
amplitude_sb.setMinimumHeight(25)
amplitude_sb.valueChanged.connect(tracker.set_amplitude)
penWidth_sb = QSpinBox()
penWidth_sb.setRange(1, 20)
penWidth_sb.setValue(tracker.pen_width)
penWidth_sb.setMaximumWidth(60)
penWidth_sb.setMinimumHeight(25)
penWidth_sb.valueChanged.connect(tracker.set_pen_width)
vertPos_sb = QSpinBox()
vertPos_sb.setRange(200, 800)
vertPos_sb.setValue(tracker.x_axis_y_coordinate)
vertPos_sb.setMaximumWidth(60)
vertPos_sb.setMinimumHeight(25)
vertPos_sb.valueChanged.connect(tracker.set_x_axis_y_coordinate)
xAxisLength_sb = QSpinBox()
xAxisLength_sb.setRange(50, 1000)
xAxisLength_sb.setValue(tracker.x_axis_offset_from_right)
xAxisLength_sb.setMaximumWidth(60)
xAxisLength_sb.setMinimumHeight(25)
xAxisLength_sb.valueChanged.connect(tracker.set_x_axis_offset_from_right)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(label1, 0, 0, 1, 1)
layout.addWidget(timeDelay_sb, 0, 1, 1, 1)
layout.addWidget(label2, 1, 0, 1, 1)
layout.addWidget(amplitude_sb, 1, 1, 1, 1)
layout.addWidget(label3, 2, 0, 1, 1)
layout.addWidget(penWidth_sb, 2, 1, 1, 1)
layout.addWidget(label4, 3, 0, 1, 1)
layout.addWidget(vertPos_sb, 3, 1, 1, 1)
layout.addWidget(label5, 4, 0, 1, 1)
layout.addWidget(xAxisLength_sb, 4, 1, 1, 1)
upper = QWidget()
upper.setLayout(layout)
#-------------------------------------------------
vbox = QVBoxLayout()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
vbox.addWidget(upper)
vbox.addStretch(1)
gb.setLayout(vbox)
return gb
def createPcCalibrationControls():
gb = QGroupBox("PC Calibration")
#-------------------------------------------
layout = QHBoxLayout()
label = QLabel("Calibration offset for 180:")
global offAt180_sb
offAt180_sb = QDoubleSpinBox()
offAt180_sb.setRange(-4.0, 0.0)
offAt180_sb.setSingleStep(0.5)
offAt180_sb.setValue(-3.5)
offAt180_sb.setMaximumWidth(60)
layout.addWidget(label)
layout.addWidget(offAt180_sb)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
upper = QWidget()
upper.setLayout(layout)
#-------------------------------------------
layout = QHBoxLayout()
btn2p5 = QPushButton("2.5")
btn2p5.clicked.connect(lambda: offAt180_sb.setValue(-2.5))
btn3 = QPushButton("3.0")
btn3.clicked.connect(lambda: offAt180_sb.setValue(-3.0))
btn3p5 = QPushButton("3.5")
btn3p5.clicked.connect(lambda: offAt180_sb.setValue(-3.5))
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(btn2p5)
layout.addWidget(btn3)
layout.addWidget(btn3p5)
middle = QWidget()
middle.setLayout(layout)
#-------------------------------------------
layout = QHBoxLayout()
label = QLabel("Running Angle offset:")
global runningAngleOffset_sb
runningAngleOffset_sb = QSpinBox()
runningAngleOffset_sb.setToolTip(
"offset in degrees to add to the angle reported by arduino")
runningAngleOffset_sb.setRange(0, 5)
runningAngleOffset_sb.setValue(2)
runningAngleOffset_sb.setMaximumWidth(60)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(label)
layout.addWidget(runningAngleOffset_sb)
lower = QWidget()
lower.setLayout(layout)
#-------------------------------------------
vbox = QVBoxLayout()
vbox.addWidget(upper)
vbox.addWidget(middle)
vbox.addWidget(lower)
vbox.addStretch(1)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
gb.setLayout(vbox)
return gb
class TwoPlots(QWidget):
''' Widget to plot 2 curves x(t) & y(t), or Vx(t) & Vy(t)'''
Ylabels = {
"position": ("X [pixel]", "Y [pixel]"),
"velocity": ("VX [pixel/s]", "VY [pixel/s]"),
"position_mm": ("X [mm]", "Y [mm]"),
"velocity_mm": ("VX [mm/s]", "VY [mm/s]")
}
CurveLabels = {
"position": ("X(t) [{}]", "Y(t) [{}]"),
"velocity": ("VX(t) {}", "VY(t) {}")
}
def __init__(self, mainWindow, quantity):
# appel du constructeur de la classe de base :
QWidget.__init__(self, mainWindow)
self.mw = mainWindow # la fenêtre de l'application principale
# Attributs (objets persistants)
self.__quantity = quantity # "position" or "velocity"
self.__data1 = None # data for the first plot
self.__data2 = None # data for tthe second
self.__figure = None # figure tracé
self.__axes1 = None # système d'axes tracé 1
self.__axes2 = None # système d'axes tracé 2
self.__canvas = None # pour le tracé matplot.lib
self.__toolbar = None # barre d'outils tracé
self.__time = None # abcissa values for plot
self.__xlim = None # xmin, xmay tracé
self.__xlabel = None # étiquette axe X (n° image ou temps [s])
self.__ylim1 = None # ymin, ymax tracé x(t)
self.__ylim2 = None # ymin, ymax tracé y(t)
self.btn_imageSize = QRadioButton("ImageSize", self)
self.btn_autoSize = QRadioButton("AutoSize", self)
self.btn_smooth_Vx = QCheckBox("Lissage Vx", self)
self.btn_smooth_Vy = QCheckBox("Lissage Vy", self)
self.x_mav_nb_pts = QSpinBox(parent=self) # X velocity moving average
self.y_mav_nb_pts = QSpinBox(parent=self) # Y velocity moving average
self.__initUI() # Initialisation de l'interface utilisateur
def __initUI(self):
if self.__quantity == "position":
for w in (self.btn_smooth_Vx, self.btn_smooth_Vy,
self.x_mav_nb_pts, self.y_mav_nb_pts):
w.setVisible(False)
w.setEnabled(False)
group = QButtonGroup(self)
group.addButton(self.btn_imageSize)
group.addButton(self.btn_autoSize)
self.btn_imageSize.toggled.connect(self.__ImageSizePlotXYLim)
self.btn_imageSize.setEnabled(False)
texte = "Tracé avec les bornes min et max de l'image"
self.btn_imageSize.setStatusTip(texte)
self.btn_imageSize.setChecked(True)
self.btn_autoSize.toggled.connect(self.__AutoSizePlotXYLim)
self.btn_autoSize.setEnabled(False)
texte = "Tracé avec les bornes min et max de la "
texte += "trajectoire calculée"
self.btn_autoSize.setStatusTip(texte)
elif self.__quantity == "velocity":
for w in (self.btn_imageSize, self.btn_autoSize):
w.setVisible(False)
w.setEnabled(False)
self.btn_smooth_Vx.stateChanged.connect(self.__smooth_Vx_wanted)
self.btn_smooth_Vy.stateChanged.connect(self.__smooth_Vy_wanted)
self.x_mav_nb_pts.setEnabled(False)
self.y_mav_nb_pts.setEnabled(False)
self.x_mav_nb_pts.setRange(3, 100)
self.y_mav_nb_pts.setRange(3, 100)
self.x_mav_nb_pts.setSingleStep(2)
self.y_mav_nb_pts.setSingleStep(2)
self.x_mav_nb_pts.valueChanged.connect(self.__smooth_vX)
self.y_mav_nb_pts.valueChanged.connect(self.__smooth_vY)
vbox = QVBoxLayout()
self.setLayout(vbox)
# Ligne 1 : tracé de l'image
self.setLayout(vbox)
self.__figure = Figure()
self.__axes1 = self.__figure.add_subplot(211)
self.__axes2 = self.__figure.add_subplot(212)
self.__figure.subplots_adjust(left=0.120,
right=0.99,
bottom=0.11,
top=0.98)
self.__canvas = FigureCanvas(self.__figure)
self.__toolbar = NavigationToolbar(self.__canvas, self)
#self.__toolbar.setMinimumWidth(450)
vbox.addWidget(self.__canvas)
hbox = QHBoxLayout()
hbox.addWidget(self.__toolbar)
hbox.addStretch()
if self.__quantity == "position":
hbox.addWidget(self.btn_imageSize)
hbox.addWidget(self.btn_autoSize)
elif self.__quantity == "velocity":
vb = QVBoxLayout()
hb = QHBoxLayout()
hb.addWidget(self.btn_smooth_Vx)
hb.addWidget(self.x_mav_nb_pts)
vb.addLayout(hb)
hb = QHBoxLayout()
hb.addWidget(self.btn_smooth_Vy)
hb.addWidget(self.y_mav_nb_pts)
vb.addLayout(hb)
hbox.addLayout(vb)
vbox.addLayout(hbox)
def reset(self):
if self.__quantity == "velocity":
for w in (self.btn_smooth_Vx, self.btn_smooth_Vy,
self.x_mav_nb_pts, self.y_mav_nb_pts):
w.setVisible(True)
w.setEnabled(True)
self.x_mav_nb_pts.setValue(self.x_mav_nb_pts.minimum())
self.y_mav_nb_pts.setValue(self.y_mav_nb_pts.minimum())
self.btn_smooth_Vx.setCheckState(Qt.Unchecked)
self.btn_smooth_Vy.setCheckState(Qt.Unchecked)
def __smooth_Vx_wanted(self, checked):
if checked:
self.x_mav_nb_pts.setEnabled(True)
else:
self.x_mav_nb_pts.setEnabled(False)
self.Plot()
def __smooth_Vy_wanted(self, checked):
if checked:
self.y_mav_nb_pts.setEnabled(True)
else:
self.y_mav_nb_pts.setEnabled(False)
self.Plot()
def __smooth_vX(self, nb_pts):
if self.btn_smooth_Vx.isChecked():
self.Plot()
else:
pass
def __smooth_vY(self, nb_pts):
if self.btn_smooth_Vy.isChecked():
self.Plot()
else:
pass
def __compute_velocity(self, U, plot_id):
"""Computes the velocity with the centered finite difference of order 1 :
V[i] = (U[i+1] - U[i-1])/(T[i+1] - T[i-1]) for i in [1,N-1]
V[0] = (U[1] - U[0])/(T[1] - T[0])
V[-1] = (U[-1] - U[-2])/(T[-1] - T[-2])
"""
V = U.copy()
T = self.__time
V[0] = (U[1] - U[0]) / (T[1] - T[0])
V[-1] = (U[-1] - U[-2]) / (T[-1] - T[-2])
V[1:-1] = (U[2:] - U[:-2]) / (T[2:] - T[:-2])
if plot_id == "x":
if self.btn_smooth_Vx.isChecked():
N = self.x_mav_nb_pts.value()
V = self.__smooth_data(V, N)
elif plot_id == "y":
if self.btn_smooth_Vy.isChecked():
N = self.y_mav_nb_pts.value()
V = self.__smooth_data(V, N)
return V
def __smooth_data(self, U, nb_pts):
"""Computes the nb_pts moving average on U."""
N = nb_pts
V = U.copy()
V.fill(np.nan)
mav = deque(maxlen=N)
# initialize the mav (moving average)
for e in U[:N]:
mav.append(e)
# move!
index, count = N // 2, 0
while count < V.shape[0] - N:
V[index] = np.mean(mav)
mav.append(U[N + count])
count += 1
index += 1
return V
def Plot(self):
target_pos = self.mw.target_pos
if target_pos is None:
return
else:
self.__data1, self.__data2, I = target_pos
scale = self.mw.imageTab.pix_to_mm_coeff
if self.__quantity == "position":
self.btn_imageSize.setEnabled(True)
self.btn_autoSize.setEnabled(True)
elif self.__quantity == "velocity":
pass
# Effacement automatiqe si demandé à chaque nouveau tracé :
if self.mw.flags["autoClearTraj"]:
if self.__axes1 is not None: self.__axes1.clear()
if self.__axes2 is not None: self.__axes2.clear()
# Récupération du nom de l'alagorithme de traitement :
algo = self.mw.imageTab.btn_algo.currentText()
# Récupération de la valeur de FP (Frame per seconde) pour calcul
# du pas de temps et des abscisses :
deltaT = None
if self.mw.imageTab.video_FPS is not None:
deltaT = 1. / self.mw.imageTab.video_FPS
self.__time = np.array(I) * deltaT
self.__xlabel = "temps [s]"
else:
self.__time = np.array(I)
self.__xlabel = "image #"
if self.__quantity == "velocity":
if deltaT is not None:
self.__data1 = self.__compute_velocity(self.__data1, "x")
self.__data2 = self.__compute_velocity(self.__data2, "y")
if self.btn_smooth_Vx.isChecked():
N = self.x_mav_nb_pts.value()
if self.btn_smooth_Vy.isChecked():
N = self.y_mav_nb_pts.value()
self.__AutoSizePlotXYLim()
else:
self.__data1, self.__data2 = None, None
self.mw.target_veloc = np.array([self.__data1, self.__data2])
else:
self.__ImageSizePlotXYLim()
if self.__data1 is None or self.__data2 is None: return
curveLabelX, curveLabelY = TwoPlots.CurveLabels[self.__quantity]
if self.__quantity == "position":
Xlabel, Ylabel = curveLabelX.format(algo), curveLabelY.format(algo)
else:
Xlabel, Ylabel = curveLabelX.format(""), curveLabelY.format("")
color = 'b' if self.mw.target_RGB is None else self.mw.target_RGB / 255
# tracé de courbe x(t)
self.__axes1.plot(self.__time,
self.__data1 * scale,
color=color,
marker='o',
markersize=2,
linewidth=.4,
label=Xlabel)
self.__axes1.grid(True)
#self.__axes1.legend(fontsize=9, framealpha=0.7,
# bbox_to_anchor=(-0.1, 1.1), loc='upper left')
self.__axes1.legend(loc='best', fontsize=10)
# tracé de courbe y(t)
self.__axes2.plot(self.__time,
self.__data2 * scale,
color=color,
marker='o',
markersize=2,
linewidth=.4,
label=Ylabel)
self.__axes2.grid(True)
#self.__axes2.legend(fontsize=9, framealpha=0.7,
# bbox_to_anchor=(1.1, 1.1), loc='upper right')
self.__axes2.legend(loc='best', fontsize=10)
self.__canvas.draw()
def __AutoSizePlotXYLim(self):
if self.mw.target_pos is None: return
y1label, y2label = TwoPlots.Ylabels[self.__quantity]
self.__xlim = np.array(
[np.nanmin(self.__time),
np.nanmax(self.__time)])
scale = self.mw.imageTab.pix_to_mm_coeff
if not self.btn_smooth_Vx.isChecked():
self.__ylim1 = np.array(
[np.nanmin(self.__data1),
np.nanmax(self.__data1)]) * scale
offset = (self.__ylim1[1] - self.__ylim1[0]) / 10
self.__ylim1 += np.array([-offset, offset])
else:
#self.__ylim1 = self.__axes1.get_ylim()
pass
if not self.btn_smooth_Vy.isChecked():
self.__ylim2 = np.array(
[np.nanmin(self.__data2),
np.nanmax(self.__data2)]) * scale
offset = (self.__ylim2[1] - self.__ylim2[0]) / 10
self.__ylim2 += np.array([-offset, offset])
else:
#self.__ylim2 = self.__axes2.get_ylim()
pass
if self.mw.imageTab.valid_scale:
y1label, y2label = TwoPlots.Ylabels[self.__quantity + "_mm"]
self.__axes1.set_xlim(*self.__xlim)
self.__axes2.set_xlim(*self.__xlim)
self.__axes1.set_ylim(*self.__ylim1)
self.__axes2.set_ylim(*self.__ylim2)
self.__axes1.set_ylabel(y1label)
self.__axes2.set_ylabel(y2label)
self.__axes2.set_xlabel(self.__xlabel)
self.__canvas.draw()
def __ImageSizePlotXYLim(self):
if self.mw.target_pos is None: return
scale = self.mw.imageTab.pix_to_mm_coeff
y1label, y2label = TwoPlots.Ylabels[self.__quantity]
w, h = self.mw.imageTab.video_size
self.__xlim = np.array(
[np.nanmin(self.__time),
np.nanmax(self.__time)])
self.__ylim1 = np.array([0, w - 1], dtype=float) * scale
self.__ylim2 = np.array([0, h - 1], dtype=float) * scale
if self.mw.imageTab.valid_scale:
y1label, y2label = TwoPlots.Ylabels[self.__quantity + "_mm"]
self.__axes1.set_xlim(*self.__xlim)
self.__axes2.set_xlim(*self.__xlim)
self.__axes1.set_ylim(*self.__ylim1)
self.__axes2.set_ylim(*self.__ylim2)
self.__axes1.set_ylabel(y1label)
self.__axes2.set_ylabel(y2label)
self.__axes2.set_xlabel(self.__xlabel)
self.__canvas.draw()
def ClearAxes(self):
if self.__axes1 is not None: self.__axes1.clear()
if self.__axes2 is not None: self.__axes2.clear()
self.__canvas.draw()
class ImageDisplay(QWidget):
video_infos = ['vidéo : {}','nb frames : {}','taille : {}','FPS : {}','durée : {:.2f} sec']
video_keys = ['videoname','nframes','size','fps','duration']
algo_traj = ['barycentre','minmax']
def __init__(self, mainWindow):
# acall the base class constructor:
super().__init__(mainWindow)
self.mw = mainWindow
# Attributs (objets persistants)
self.img_lbl = QLabel(self) # to display the current image
self.img_lbl.installEventFilter(self) # filter to catch evenements
self.selectTargetRect = None # display a rectangle to show teh target color selection
self.rubberBand = QRubberBand(QRubberBand.Line, self)
# Boutons pour avancer/reculer
self.btn_prev = QPushButton(QIcon("icones/go-prev.png"), "", self)
self.btn_next = QPushButton(QIcon("icones/go-next.png"), "", self)
self.btn_first = QPushButton(QIcon("icones/go-first.png"), "", self)
self.btn_last = QPushButton(QIcon("icones/go-last.png"), "", self)
self.btn_traj = QPushButton(QIcon("icones/extract.png"), "Extraire...", self)
self.btn_clear = QPushButton(QIcon("icones/clear.png"), "Effacer courbes...", self)
self.btn_exportCSV = QPushButton(QIcon("icones/exportCSV.png"), "Export CSV", self)
self.btn_algo = QComboBox(self)
self.image_index = QLabel(self)
# widget QSpinBox
self.images_step = QSpinBox(parent=self)
self.images_firstRank = QSpinBox(parent=self)
self.images_lastRank = QSpinBox(parent=self)
# QLabel to display the target color
self.target_color_label = QLabel("target color",parent=self)
self.picked_color = QLabel(self)
self.video_path = None # Chemin de la dernière vidéo
self.images_dir = None # Dossier contenant les images
self.__img_idx = None # Rang de l'image affichée
self.img_path = None # nom du chemin de l'image courante
self.nb_img = None # nombre d'images
self.video_name = None # nom de la video ("aaaaaa.mp4")
self.video_nframes = None # nombre d'images dans la video
self.video_size = None # taille (width, height) des images
self.video_FPS = None # nombre d'images par seconde
self.video_duration = None # durée de la video en secondes
self.videoLabels = [] # liste de QLabel contenant les infos vidéo
self.dico_video = {} # dictionnaire des méta-données
self.dico_unit = {} # dictionary "pixels", "mm"
self.scale_pixel = None # nombre de pixels pour conversion en mm
self.scale_mm = None # nbre de mm pour scale_pixel
self.valid_scale = False # données de l'échelle valides ou pas
self.pix_to_mm_coeff= 1. # le coefficient de converion pixels -> mm
self.dicoScale = {} # dictionnaire des QWidget d'info scale
self.lbl_epsilon = None # label epsilon
self.epsi_spin = None # boite de choix de epsilon
# créer l'onglet de visualisation image """
self.__initUI()
self.scaleInfoVisible(False)
self.__epsilonVisible(False)
def __initUI(self):
# Onglet "Visualisation images"
vbox = QVBoxLayout()
# Ligne 1 : extraction trajec
self.picked_color.setFrameStyle(QFrame.StyledPanel | QFrame.Plain);
line1 = QHBoxLayout()
line1.addStretch(1)
line1.addWidget(self.btn_algo)
line1.addWidget(self.btn_traj)
line1.addWidget(self.target_color_label)
line1.addWidget(self.picked_color)
line1.addWidget(self.btn_clear)
line1.addWidget(self.btn_exportCSV)
line1.addStretch(1)
# Ligne 2 : infos video + visu image
line2 = QHBoxLayout()
# boîte d'infos sur la vidéo
infoVBox = QVBoxLayout()
for _ in ImageDisplay.video_infos:
label = QLabel(self)
label.setFrameStyle(QFrame.StyledPanel | QFrame.Plain);
infoVBox.addWidget(label)
self.videoLabels.append(label)
infoVBox.addStretch()
widget = QLabel("Conversion pixels -> mm", self)
self.dicoScale['Pixels-mm'] = widget
infoVBox.addWidget(widget)
grid = QGridLayout()
infoVBox.addLayout(grid)
widget = QLabel("pixels ",self)
self.dicoScale['pixels'] = widget
grid.addWidget(widget,1,1)
self.scale_pixel = QLineEdit(self)
self.dicoScale['pixelsForMM'] = self.scale_pixel
grid.addWidget(self.scale_pixel,1,2)
widget = QLabel("millimètres ",self)
self.dicoScale['millimeters'] = widget
grid.addWidget(widget,2,1)
self.scale_mm = QLineEdit(self)
self.dicoScale['mmForPixels'] = self.scale_mm
grid.addWidget(self.scale_mm,2,2)
self.lbl_epsilon = QLabel("Epsilon ",self)
grid.addWidget(self.lbl_epsilon,5,1)
self.epsi_spin = QSpinBox(self)
self.epsi_spin.setRange(1,50)
self.epsi_spin.setSingleStep(1)
self.epsi_spin.setValue(10)
grid.addWidget(self.epsi_spin,5,2)
infoVBox.addStretch()
line2.addLayout(infoVBox)
line2.addStretch(1)
line2.addWidget(self.img_lbl) # le QLabel por afficher l'image
line2.addStretch(1)
# line 3 : navigation boutons
self.image_index.setFrameStyle(QFrame.Panel | QFrame.Sunken)
self.image_index.setText(" ")
line3 = QHBoxLayout()
line3.addStretch(1)
line3.addWidget(self.btn_first)
line3.addWidget(self.btn_prev)
line3.addWidget(self.image_index)
line3.addWidget(self.btn_next)
line3.addWidget(self.btn_last)
line3.addStretch(1)
# line 4 : first , step, last image selection
line4 = QHBoxLayout()
line4.addStretch(1)
line4.addWidget(self.images_firstRank)
line4.addWidget(self.images_step)
line4.addWidget(self.images_lastRank)
line4.addStretch(1)
vbox.addLayout(line1)
vbox.addStretch(1)
vbox.addLayout(line2)
vbox.addStretch(1)
vbox.addLayout(line3)
vbox.addLayout(line4)
self.setLayout(vbox)
self.buttonsState()
self.__buttonsConnect()
self.__setVideoLabelVisible(False)
def __setVideoLabelVisible(self, state):
for label in self.videoLabels:
label.setVisible(state)
def __buttonsConnect(self):
self.btn_traj.clicked.connect(self.extract_trajectoire)
self.btn_clear.clicked.connect(self.mw.clearPlots)
self.btn_exportCSV.clicked.connect(self.mw.ExportCSV)
self.btn_prev.clicked.connect(self.prev_image)
self.btn_next.clicked.connect(self.next_image)
self.btn_first.clicked.connect(self.first_image)
self.btn_last.clicked.connect(self.last_image)
self.images_step.valueChanged.connect(self.__step_changed)
self.images_firstRank.valueChanged.connect(self.__first_rank_changed)
self.images_lastRank.valueChanged.connect(self.__last_rank_changed)
def buttonsState(self, importCSV=False):
self.btn_traj.setEnabled(False)
self.picked_color.setText("X")
self.picked_color.setEnabled(False)
self.btn_traj.setStatusTip('Extrait la trajectoire de la cible'+
'dont la couleur a été choisie')
self.target_color_label.setEnabled(False)
self.picked_color.setStyleSheet('background-color : rgb(255, 255, 255)')
self.btn_clear.setEnabled(False)
self.btn_clear.setStatusTip('Nettoye tous les tracés des onglets'+
'<trajectoire> et <X(t), Y(t)>')
self.btn_exportCSV.setEnabled(False)
texte = "Export des données dans un fichier CSV"
self.btn_exportCSV.setStatusTip(texte)
if not importCSV: self.btn_algo.addItems(ImageDisplay.algo_traj)
self.btn_algo.setEnabled(False)
self.btn_prev.setEnabled(False)
self.btn_prev.setStatusTip("affiche l'image précédente")
self.btn_next.setEnabled(False)
self.btn_next.setStatusTip("affiche l'image suivante")
self.btn_first.setEnabled(False)
self.btn_first.setStatusTip("affiche la première image à traiter")
self.btn_last.setEnabled(False)
self.btn_last.setStatusTip("affiche la dernière image à traiter")
# SpinBoxes parameters:
self.images_step.setRange(1,1000)
self.images_step.setSingleStep(1)
self.images_step.setValue(1)
self.images_step.setPrefix("step: ")
self.images_step.setEnabled(False)
self.images_step.setStatusTip("Fixe le pas pour passer d'une image à l'autre")
self.images_firstRank.setRange(1,1000)
self.images_firstRank.setSingleStep(1)
self.images_firstRank.setValue(1)
self.images_firstRank.setPrefix("first: ")
self.images_firstRank.setEnabled(False)
self.images_firstRank.setStatusTip("Fixe le rang de la première image à traiter")
self.images_lastRank.setRange(1,10000)
self.images_lastRank.setSingleStep(1)
self.images_lastRank.setValue(1)
self.images_lastRank.setPrefix("last: ")
self.images_lastRank.setEnabled(False)
self.images_lastRank.setStatusTip("Fixe le rang de la dernière image à traiter")
def __first_rank_changed(self, val):
if self.img_idx is None: return
if self.img_idx < val:
self.img_idx = val
self.show_image()
def __last_rank_changed(self, val):
if self.img_idx is None: return
if self.img_idx > val:
self.img_idx = val
self.show_image()
def __step_changed(self, val):
if self.img_idx is None: return
def setTextInfoVideoGrid(self):
for field, name, key in zip(self.videoLabels,
ImageDisplay.video_infos,
ImageDisplay.video_keys):
mess = name.format(self.dico_video.get(key,'?'))
field.setText(mess)
self.__setVideoLabelVisible(True)
def scaleInfoVisible(self, state):
for widget in self.dicoScale.values():
widget.setVisible(state)
def __epsilonVisible(self, state):
self.lbl_epsilon.setVisible(state)
self.epsi_spin.setVisible(state)
def open_video(self):
'''Lance un sélecteur de fichier pour choisir la vidéo à traiter.'''
fname = QFileDialog.getOpenFileName(None,
'Choisir une vidéo',
self.mw.cur_dir,
'Fichier vidéo (*.mp4)')
if fname[0] != '' :
# un fichier vidéo a été chosi :
vp = fname[0]
if self.video_path == vp :
name = os.path.basename(vp)
rep = QMessageBox.question(self, # widget parent de QMessageBox
'Question', # texte du bandeau de la fenêtre
'Voulez-vous recharger le fichier video {} ?'.format(name),
QMessageBox.Yes | QMessageBox.No, # afficher les boutons Yes et No
QMessageBox.No) # bouton No sélectionné par défaut
if rep == QMessageBox.No: return
# fichier vidéo à traiter => faire le split des images :
self.video_path = vp
self.extract_images_from_video()
def load_images_from_directory(self):
'''Charge les images '*.png' contenue dans le répertoire
des images choisi avec un sélecteur graphique.'''
# Choix du répertoire avec un sélecteur de fichier :
dname = QFileDialog.getExistingDirectory(None,
'Choisir un dossier images',
self.mw.image_dir)
if dname != '' :
# un répertoire valide a été choisi :
self.video_path = None
self.images_dir = dname + "/"
try:
# Lecture du fichier ascii des méta-données
with open(self.images_dir + "metaData.txt", "r") as F:
data = F.read()
exec('self.dico_video = '+data)
except:
rep = QMessageBox.critical(
None, # widget parent de QMessageBox
'Erreur', # bandeau de la fenêtre
'Pas de fichier de méta-données dans le répertoire'+\
' <{}>'.format(os.path.basename(dname)),
QMessageBox.Ok)
return
print("méta données :", self.dico_video)
self.parse_meta_data()
self.setTextInfoVideoGrid()
# Mettre à jour l'application avec les nouvelles images chargées :
self.update_images()
def extract_trajectoire(self):
'''Méthode utilisée pour extraire la trajectoire du centre de la
cible pour toutes les images de la vidéo.'''
# Récupérer l'algorithme de calcul du centre de la cible :
algo = self.btn_algo.currentText()
# Définition de la liste dans laquelle on va récupérer les coordonnées
# du centre cible pour toutes les images :
target_pos = []
# Création d'un objet ProgressBar qui va lancer le travail
# d'extraction de la cible dans les images tout en affichant une
# barre d'avancement :
first = self.images_firstRank.value()
last = self.images_lastRank.value()
step = self.images_step.value()
last = last - (last - first) % step
first_last_step = (first, last, step)
pg = ProgressBar(self.images_dir, self)
pg.configure_for_target_extraction(self.mw.target_RGB,
algo,
self.epsi_spin.value(),
target_pos,
first_last_step)
ret = pg.exec_() # lance la barre et le travail d'extraction...
print("retour de pg.exec_() :",ret)
if ret != 0:
self.mw.target_pos = None
return
target_pos = np.array(target_pos)
width, height = self.video_size
# l'axe verticale est retourné et decalé:
target_pos[1] = height - target_pos[1]
self.scale_XY()
self.mw.target_pos = target_pos
self.display_plots()
# remettre le bouton extraire_trajectoire disabled:
self.btn_exportCSV.setEnabled(True)
def display_plots(self):
self.mw.clearPlots()
# Plot trajectory (X(t), Y(t)) :
self.mw.onePlot.setEnabled(True)
self.mw.onePlot.Plot()
# Plot curves X(t) and Y(t)
self.mw.twoPlots_xy.setEnabled(True)
self.mw.tabs.setCurrentWidget(self.mw.twoPlots_xy)
self.mw.twoPlots_xy.Plot()
# Plot curves VX(t) and VY(t)
self.mw.twoPlots_VxVy.setEnabled(True)
self.mw.tabs.setCurrentWidget(self.mw.twoPlots_xy)
self.mw.twoPlots_VxVy.Plot()
def extract_images_from_video(self) :
# name of the video file without path and suffix:
videoname = os.path.basename(self.video_path)[:-4]
# directory where to put extracted iamges:
self.images_dir = self.mw.image_dir + videoname + "/"
if os.path.isdir(self.images_dir) :
print("Effacement de tous les fichiers de '{}'"\
.format(self.images_dir))
for fn in os.listdir(self.images_dir) :
os.remove(self.images_dir+fn)
else :
os.mkdir(self.images_dir)
video = cv2.VideoCapture(self.video_path)
self.dico_video['nframes'] = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
self.dico_video['size'] = (int(video.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(video.get(cv2.CAP_PROP_FRAME_HEIGHT)))
self.dico_video['fps'] = int(video.get(cv2.CAP_PROP_FPS))
self.dico_video['duration'] = video.get(cv2.CAP_PROP_FRAME_COUNT)/video.get(cv2.CAP_PROP_FPS)
self.dico_video['videoname'] = os.path.basename(self.video_path)
self.parse_meta_data()
self.dico_video["videoname"] = videoname+".mp4"
self.setTextInfoVideoGrid()
# Création d'un objet ProgressBar qui va lancer le travail
# d'extraction des images tout en affichant une barre d'avancement :
pg = ProgressBar(self.images_dir, self)
pg.configure_for_video_extraction(video, self.mw.image_fmt)
ret = pg.exec_()
print("retour de pg.exec_() :", ret)
if ret != 0: return
# MAJ de la liste des fichiers images :
self.update_images()
# écriture des méta-data dans le fichier 'nom_video'.info
with open(self.mw.image_dir+videoname+"/metaData.txt", "w") as F:
F.write(str(self.dico_video))
def computeTargetColor(self, draw_selection=False):
col_min,row_min,col_max,row_max = self.selection.getCoords()
print("Pixels selectionnés : lignes [{},{}] colonnes [{},{}]".\
format(row_min, row_max, col_min, col_max))
tab = imread(self.img_path)
self.target_pix = tab[row_min:row_max+1, col_min:col_max+1, :]
R = round(self.target_pix[:,:,0].mean())
G = round(self.target_pix[:,:,1].mean())
B = round(self.target_pix[:,:,2].mean())
self.mw.target_RGB = np.array([R, G, B], dtype=int)
print("RGB sélection dans <{}> :".format(os.path.basename(self.img_path)),
self.mw.target_RGB)
draw_selection = self.mw.flags["drawTargetSelection"]
if draw_selection:
self.show_image()
print("drawTargetSelection")
#if self.selectTargetRect is not None : del self.selectTargetRect
# create painter instance with pixmap
self.selectTargetRect = QPainter(self.img_lbl.pixmap())
# set rectangle color and thickness
self.penRectangle = QPen(QColor(0,0,0))
self.penRectangle.setWidth(2)
# draw rectangle on painter
self.selectTargetRect.begin(self)
self.selectTargetRect.setPen(self.penRectangle)
self.selectTargetRect.drawRect(col_min,row_min,
col_max-col_min,row_max-row_min)
self.selectTargetRect.setOpacity(0.1)
self.selectTargetRect.end()
#self.show_image()
self.btn_traj.setEnabled(True)
self.btn_algo.setEnabled(True)
self.btn_clear.setEnabled(True)
self.target_color_label.setEnabled(True)
self.picked_color.setStyleSheet('background-color : rgb({},{},{})'.format(R, G, B))
@property
def img_idx(self): return self.__img_idx
@img_idx.setter
def img_idx(self, index):
self.__img_idx = index
self.image_index.setText(str(index))
def update_images(self) :
'''Méthode à exécuter quand de nouvelles images sont apparues
après une extraction d'images depuis une vidéo par exemple.
Cette méthode :
- met à jour des attributs qui dépendant de la liste des images,
- met à jour l'état de certains boutons
- fait afficher la première image et un message d'information.'''
if self.images_dir is None :
self.__img_idx = None
#self.btn_prev.setEnabled(False)
self.btn_prev.setStatusTip("")
#self.btn_next.setEnabled(False)
self.btn_next.setStatusTip("")
self.images_step.setEnabled(False)
self.images_firstRank.setEnabled(False)
self.images_lastRank.setEnabled(False)
else :
self.buttonsState()
self.mw.clearPlots()
self.mw.twoPlots_VxVy.reset()
# liste des noms des fichiers image pour avoir leur nombre :
file_names = [ f for f in os.listdir(self.images_dir) \
if f.endswith('.png')]
file_names.sort()
self.nb_img = len(file_names)
# Update spinBox:
self.images_step.setEnabled(True)
self.images_firstRank.setEnabled(True)
self.images_lastRank.setEnabled(True)
self.images_firstRank.setValue(1)
self.images_step.setValue(1)
self.images_lastRank.setValue(self.nb_img)
self.images_firstRank.setMaximum(self.nb_img)
self.images_lastRank.setMaximum(self.nb_img)
self.images_step.setMaximum(self.nb_img)
# MAJ des boutons prev et next
self.img_idx = self.images_firstRank.value()
self.btn_prev.setEnabled(True)
self.btn_first.setEnabled(True)
self.btn_prev.setStatusTip("charge l'image précédente")
self.btn_next.setEnabled(True)
self.btn_last.setEnabled(True)
self.btn_next.setStatusTip("afficher "+self.mw.image_fmt.format(\
self.img_idx+self.images_step.value()))
self.show_image()
self.scaleInfoVisible(True)
self.__epsilonVisible(True)
self.mw.tabs.setCurrentWidget(self)
self.scale_mm.clear()
self.scale_mm.setText("???")
self.scale_pixel.clear()
try:
text = str(self.video_size[1])
except:
text = ""
self.scale_pixel.setText(text)
self.mw.twoPlots_VxVy.reset()
if self.mw.flags["displayInfo"]:
rep = QMessageBox.information(
None, # widget parent de QMessageBox
'Information', # bandeau de la fenêtre
'Vous pouvez maintenant sélectionner une couleur de cible'+\
'avec la souris...',
QMessageBox.Ok)
def show_image(self):
'''Affiche l'image dont le numéro est donné par l'attribut 'img_idx'.'''
if self.img_idx is None :
self.img_path = ''
else :
self.img_path = self.images_dir+self.mw.image_fmt.format(self.img_idx)
pixmap = QPixmap(self.img_path)
self.img_lbl.setPixmap(pixmap)
self.img_lbl.setStatusTip(os.path.basename(self.img_path))
def first_image(self) :
if self.img_idx == None : return
self.img_idx = self.images_firstRank.value()
self.mw.statusBar().showMessage("")
self.show_image()
def prev_image(self) :
if self.img_idx == None : return
if self.img_idx >= self.images_firstRank.value() + self.images_step.value():
self.img_idx -= self.images_step.value()
self.mw.statusBar().showMessage("")
self.show_image()
def last_image(self) :
if self.img_idx == None : return
self.img_idx = self.images_lastRank.value() # rank of last image to process
self.mw.statusBar().showMessage("")
self.show_image()
def next_image(self) :
if self.img_idx == None : return
if self.img_idx <= self.images_lastRank.value()-self.images_step.value():
self.img_idx += self.images_step.value()
self.mw.statusBar().showMessage("")
self.show_image()
def parse_meta_data(self):
self.video_nframes = self.dico_video.get('nframes', None)
self.video_size = self.dico_video.get('size', None)
self.video_FPS = self.dico_video.get('fps', None)
self.video_duration = self.dico_video.get('duration', None)
self.video_name = self.dico_video.get('videoname',"none.mp4")
if self.mw.flags["debug"]:
info= " nb images : {},\n taille image : {},\n FPS : {} image/sec,\n durée : {.2f} sec."
info = info.format(self.video_nframes,
self.video_size,
self.video_FPS,
self.video_duration)
QMessageBox.about(None, # widget parent de QMessageBox
'Informations video {}'.format(self.video_name),
info)
def eventFilter(self, object, event):
if object == self.img_lbl :
if event.type() == QEvent.MouseButtonPress:
self.mousePressInLabel(event)
return True
elif event.type() == QEvent.MouseButtonRelease:
self.mouseReleaseInLabel(event)
return True
elif event.type() == QEvent.MouseMove:
self.mouseMoveInLabel(event)
return True
return False
def mousePressInLabel(self, event):
if event.button() == Qt.LeftButton:
self.pt1 = event.pos()
self.pt1_rect = self.img_lbl.mapTo(self, self.pt1)
print("\nCoord. pt1 image :",self.pt1)
self.rubberBand.setGeometry(QRect(self.pt1_rect, QSize()))
self.rubberBand.show()
self.mw.statusBar().showMessage('sélection en cours....')
def mouseMoveInLabel(self, event):
if not self.pt1.isNull():
pt = self.img_lbl.mapTo(self,event.pos())
self.rubberBand.setGeometry(QRect(self.pt1_rect, pt).normalized())
def mouseReleaseInLabel(self, event):
if event.button() == Qt.LeftButton:
self.pt2 = event.pos()
print("Coord. pt2 image :", self.pt2)
self.rubberBand.hide()
self.selection = QRect(self.pt1, self.pt2).normalized()
print(self.selection)
self.computeTargetColor()
def scale_XY(self):
self.valid_scale = False
self.pix_to_mm_coeff = 1.
try :
pixels = float(self.scale_pixel.text())
mm = float(self.scale_mm.text())
except :
if self.mw.flags["displayInfo"]:
info = 'Les données de conversion Pixels -> mm n\'ont pas été '
info += 'complétées.. les ordonnées des tracés seront en pixels.'
rep = QMessageBox.information(None, # parent de QMessageBox
'Info', # bandeau de la fenêtre
info, QMessageBox.Ok)
return
self.valid_scale = True
self.pix_to_mm_coeff = mm/pixels
print("valid scale : ", self.pix_to_mm_coeff)
class GUI(QtWidgets.QMainWindow):
def __init__(self):
'''Asetetaan muuttujille alkuarvoja ohjelman suorittamiseksi'''
super().__init__()
self.title = "Lujuusanalysaattori"
self.left = 200
self.top = 200
self.width = 1300
self.height = 700
self.palkin_default_pituus = 5
self.square_size = 10
self.ikkuna()
self.button_height = 75
self.button_width = 150
self.button_separation = 25
self.x = 0
self.y = 0
self.palkin_leveys = 700
self.palkin_korkeus = 75
self.palkin_keskipiste = 650
self.palkin_paatypiste = 1000
self.yksikko_arvo = 0
self.voima = 20
self.maks_jannitys = "-"
self.asteikko_teksti = QGraphicsSimpleTextItem()
'''Lisää QGraphicsScenen ruudukon piirtämistä varten'''
self.scene = QtWidgets.QGraphicsScene()
self.scene.setSceneRect(0, -20, self.width - 200, self.height - 100)
'''Suoritetaan lukuisia metodeja, jolla ohjelma "alustetaan"'''
self.aloita_simulaatio()
self.simulaatioikkuna()
self.simulaatio_nappi()
self.materiaali_valikko()
self.uusi_palkki_nappi()
self.lisaa_tuki_nappi()
self.lisaa_ulkoinen_voima_nappi()
self.poista_ulkoinen_voima_nappi()
self.vaihda_tuki_nappi()
Ominaisuudet.alkuarvot(self)
self.lisaa_palkki()
self.palkin_pituus_valikko()
self.yksikko_pituus()
self.asteikko()
self.lisaa_asteikko_arvo()
self.asteikko_teksti.hide()
self.tulos_teksti()
self.lisaa_seina_tuki()
self.lisaa_tuki_alhaalta()
self.ulkoinen_voima_valikko()
self.ulkoinen_voima_nuoli_alatuki()
self.ulkoinen_voima_nuoli_seinatuki()
Ominaisuudet.alkuarvot(self)
'''Asetetaan tietyille napeille tietty näkyvyys'''
self.lisaa_tuki.setEnabled(False)
self.simuloi.setEnabled(False)
self.show()
def ikkuna(self):
'''Tekee ohjelman pääikkunan'''
self.setGeometry(self.left, self.top, self.width, self.height)
self.setWindowTitle('Lujuusanalysaattori')
self.horizontal = QtWidgets.QHBoxLayout()
'''Luo menubarin'''
self.uusiAction = QAction("Uusi simulaatio", self)
self.uusiAction.setStatusTip("Luo uusi rakenne")
self.uusiAction.triggered.connect(self.uusi_rakenne)
self.uusiAction.setEnabled(True)
self.uusiAction.setShortcut("Ctrl+N")
self.tallennaAction = QAction("Tallenna simulaatio", self)
self.tallennaAction.setStatusTip("Tallenna simulaatio")
self.tallennaAction.triggered.connect(self.tallenna_rakenne)
self.tallennaAction.setEnabled(False)
self.tallennaAction.setShortcut("Ctrl+S")
self.avaaAction = QAction("Lataa simulaatio", self)
self.avaaAction.setStatusTip("Lataa simulaatio tiedostosta")
self.avaaAction.triggered.connect(self.lataa_tallennettu_rakenne)
self.avaaAction.setShortcut("Ctrl+O")
self.exitAction = QAction("Exit", self)
self.exitAction.setToolTip("Lopeta ohjelma")
self.exitAction.triggered.connect(self.close_application)
self.exitAction.setShortcut("Ctrl+E")
self.statusBar()
mainMenu = self.menuBar()
fileMenu = mainMenu.addMenu('&File')
aboutMenu = mainMenu.addMenu('&About')
fileMenu.addAction(self.uusiAction)
fileMenu.addAction(self.avaaAction)
fileMenu.addAction(self.tallennaAction)
fileMenu.addAction(self.exitAction)
def tallenna_rakenne(self):
'''Hoitaa rakenteen tallentamisen'''
tallennus = Tallennin.tallenin(self)
if tallennus == True:
'''Kerrotaan käyttäjälle, että tallennus onnistui'''
msgBox = QMessageBox()
msgBox.setText("Tallennus onnistui!")
msgBox.setWindowTitle("Onnistunut Tallennus")
msgBox.setMinimumWidth(50)
msgBox.addButton(QPushButton('OK'), QMessageBox.NoRole)
msgBox.exec_()
def lataa_tallennettu_rakenne(self):
'''Metodi avaa QFileDialog ikkunan, josta käyttäjä valitsee tiedoston, jossa aiemmin tallennettu rakenne sijaitsee. Vain .txt -tiedostot
ovat ladattavissa '''
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
tiedosto, _ = QFileDialog.getOpenFileName(self,
"Valitse tiedosto",
"",
"txt Files (*.txt)",
options=options)
lataus = Lataaja.lataaja(self, tiedosto)
if lataus == False:
return
if lataus == True:
self.uusi_rakenne()
Lataaja.lataaja(self, tiedosto)
tuen_tyyppi = Ominaisuudet.palauta_tuen_tyyppi(self)
'''Jos tuki on seinästä, piirretään sitä vastaava grafiikka'''
if tuen_tyyppi == 0:
self.nayta_seina_tuki()
self.gradient_seina_tuki()
'''Jos tuki on alhaalta, piirretään sitä vastaava grafiikka'''
if tuen_tyyppi == 1:
self.nayta_tuki_alhaalta()
self.gradient_alatuki()
if tuen_tyyppi != 2:
self.vaihda_tuki.show()
self.lisaa_tuki.hide()
'''Jos ulkoinen voima on asetettu, piirretään se'''
ulkoinen_voima = int(
Ominaisuudet.onko_ulkoinen_voima_asetettu(self))
if ulkoinen_voima == 1:
self.nayta_ulkoinen_voima()
self.nayta_palkki()
Laskin.laskin(self)
self.paivita_tulos_teksti()
self.tulos.show()
self.sp.setValue(float(Ominaisuudet.palauta_palkin_pituus(self)))
self.uusiAction.setEnabled(True)
self.simuloi.setEnabled(True)
'''Kerrotaan käyttäjälle, että kaikki onnistui'''
msgBox = QMessageBox()
msgBox.setText("Lataus onnistui!")
msgBox.setWindowTitle("Onnistunut lataus")
msgBox.addButton(QPushButton('OK'), QMessageBox.NoRole)
msgBox.exec_()
def aloita_simulaatio(self):
'''Aloittaa simulaation'''
self.setCentralWidget(QtWidgets.QWidget())
self.horizontal = QtWidgets.QHBoxLayout()
self.centralWidget().setLayout(self.horizontal)
def simulaatioikkuna(self):
'''lisää view näyttämistä varten'''
self.view = QtWidgets.QGraphicsView(self.scene, self)
self.view.adjustSize()
self.view.show()
self.horizontal.addWidget(self.view)
def uusi_palkki_nappi(self):
'''Luo Uusi palkki -napin'''
self.uusi_palkki = QPushButton('Uusi palkki')
self.uusi_palkki.setToolTip("Lisää uusi palkki")
self.uusi_palkki.move(0, 0)
self.uusi_palkki.resize(self.button_width, self.button_height)
self.uusi_palkki.font = QtGui.QFont()
self.uusi_palkki.font.setPointSize(12)
self.uusi_palkki.setFont(self.uusi_palkki.font)
self.uusi_palkki.setEnabled(True)
self.scene.addWidget(self.uusi_palkki)
self.uusi_palkki.clicked.connect(self.nayta_palkki)
def nayta_palkki(self):
'''Näyttää kaikki palkkiin liittyvät komponentit sekä asettaa uusi palkki -napin toimimattomaksi'''
self.rect.show()
self.palkin_pituus.show()
self.sp.show()
self.yksikko.show()
self.asteikko_teksti.show()
self.line.show()
self.nuoli_1.show()
self.nuoli_2.show()
self.uusi_palkki.setEnabled(False)
self.lisaa_tuki.setEnabled(True)
self.materiaali_valinta.setEnabled(True)
def lisaa_palkki(self):
'''lisää palkin'''
self.rect = QGraphicsRectItem(300, 200, self.palkin_leveys,
self.palkin_korkeus)
self.rect.setBrush(QBrush(4))
self.scene.addItem(self.rect)
self.rect.hide()
self.lisaa_tuki.setEnabled(True)
'''Aina kun on uusi palkki luotu, voidaan aloittaa simulaatio alusta'''
self.uusiAction.setEnabled(True)
def lisaa_tuki_nappi(self):
'''Luo Lisää tuki -napin'''
self.lisaa_tuki = QPushButton("Lisää tuki")
self.lisaa_tuki.setToolTip("Lisää tuki")
self.lisaa_tuki.move(0, self.button_height + self.button_separation)
self.lisaa_tuki.resize(self.button_width, self.button_height)
self.lisaa_tuki.font = QtGui.QFont()
self.lisaa_tuki.font.setPointSize(12)
self.lisaa_tuki.setFont(self.lisaa_tuki.font)
self.lisaa_tuki.setEnabled(False)
self.lisaa_tuki.clicked.connect(self.valitse_tuki)
self.scene.addWidget(self.lisaa_tuki)
def vaihda_tuki_nappi(self):
'''Luo vaihda tuki -napin'''
self.vaihda_tuki = QPushButton("Vaihda tuki")
self.vaihda_tuki.setToolTip("Vaihda tuki")
self.vaihda_tuki.move(0, self.button_height + self.button_separation)
self.vaihda_tuki.resize(self.button_width, self.button_height)
self.vaihda_tuki.setFont(self.lisaa_tuki.font)
self.vaihda_tuki.clicked.connect(self.valitse_tuki)
self.scene.addWidget(self.vaihda_tuki)
self.vaihda_tuki.hide()
def valitse_tuki(self):
'''Tuen valinta.
Jos tuki on seinästä (tyyppi = 0), kysytään halutaanko vaihtaa.
Jos haluaa muutetaan tuen grafiikka ja arvo'''
if Ominaisuudet.palauta_tuen_tyyppi(self) == 0:
msgBox = QMessageBox()
msgBox.setText("Haluatko vaihtaa tuen tyyppiä?")
msgBox.addButton(QPushButton('En'), QMessageBox.NoRole)
msgBox.addButton(QPushButton('Kyllä'), QMessageBox.YesRole)
vastaus = msgBox.exec_()
self.rect.setBrush(QBrush(4))
if vastaus == 1:
self.viiva_1.hide()
self.viiva_2.hide()
self.viiva_3.hide()
self.viiva_4.hide()
self.nayta_tuki_alhaalta()
if int(Ominaisuudet.onko_ulkoinen_voima_asetettu(self)) == 1:
self.viiva.hide()
self.nuoli_3.hide()
self.viiva_5.show()
self.nuoli_6.show()
Ominaisuudet.tuki(self, 1)
return
'''Jos tuki on alhaalta (tyyppi = 1), kysytään halutaanko vaihtaa.
Jos haluaa muutetaan tuen grafiikka ja arvo'''
if Ominaisuudet.palauta_tuen_tyyppi(self) == 1:
msgBox = QMessageBox()
msgBox.setText("Haluatko vaihtaa tuen tyyppiä?")
msgBox.addButton(QPushButton('Kyllä'), QMessageBox.YesRole)
msgBox.addButton(QPushButton('En'), QMessageBox.NoRole)
vastaus = msgBox.exec_()
self.rect.setBrush(QBrush(4))
if vastaus == 0:
Ominaisuudet.tuki(self, 0)
self.nuoli_4.hide()
self.nuoli_5.hide()
self.nayta_seina_tuki()
if int(Ominaisuudet.onko_ulkoinen_voima_asetettu(self)) == 1:
self.viiva.show()
self.nuoli_3.show()
self.viiva_5.hide()
self.nuoli_6.hide()
if vastaus == 1:
pass
'''Jos tukea ei ole (tyyppi = 2). Tuen tyypin valinta'''
if Ominaisuudet.palauta_tuen_tyyppi(self) == 2:
msgBox = QMessageBox()
msgBox.setText("Valitse tuen tyyppi")
msgBox.addButton(QPushButton('Seinätuki'), QMessageBox.YesRole)
msgBox.addButton(QPushButton('Tuki alhaalta'), QMessageBox.NoRole)
vastaus = msgBox.exec_()
self.vaihda_tuki.show()
self.lisaa_tuki.hide()
if vastaus == 0:
self.nayta_seina_tuki()
Ominaisuudet.tuki(self, 0)
if vastaus == 1:
self.nayta_tuki_alhaalta()
Ominaisuudet.tuki(self, 1)
'''Joka tapauksessa asetetaan ulkoisen voiman lisääminen mahdolliseksi
sekä maalataan palkki normaaliksi'''
self.lisaa_ulkoinen_voima.setEnabled(True)
self.simuloi.setEnabled(True)
def nayta_seina_tuki(self):
'''Näytetään seinätukea kuvaavat grafiikat'''
self.viiva_1.show()
self.viiva_2.show()
self.viiva_3.show()
self.viiva_4.show()
def nayta_tuki_alhaalta(self):
'''Näytetään alatukea kuvaavat grafiikat'''
self.nuoli_4.show()
self.nuoli_5.show()
def paivita_tuen_tyyppi(self, tyyppi):
'''Päivittää tuen tyypin arvon Ominaisuudet luokassa'''
Ominaisuudet.tuki(self, tyyppi)
def lisaa_seina_tuki(self):
'''Piirtää seinätukea kuvaavat viivat sekä asettaa self.tuen_tyyppi arvoksi
Asettaa SIMULOI-napin painettavaksi'''
viiva = QtGui.QPen(QtCore.Qt.black, 2)
viiva.setStyle(QtCore.Qt.SolidLine)
self.viiva_1 = QGraphicsLineItem(QtCore.QLineF(300, 202, 275, 225))
self.viiva_2 = QGraphicsLineItem(QtCore.QLineF(300, 222, 275, 245))
self.viiva_3 = QGraphicsLineItem(QtCore.QLineF(300, 242, 275, 265))
self.viiva_4 = QGraphicsLineItem(QtCore.QLineF(300, 262, 275, 285))
self.scene.addItem(self.viiva_1)
self.scene.addItem(self.viiva_2)
self.scene.addItem(self.viiva_3)
self.scene.addItem(self.viiva_4)
self.viiva_1.hide()
self.viiva_2.hide()
self.viiva_3.hide()
self.viiva_4.hide()
tyyppi = 0
Ominaisuudet.tuki(self, tyyppi)
self.simuloi.setEnabled(True)
def lisaa_tuki_alhaalta(self):
'''Piirtää alhaalta tukemista kuvaavat grafiikat
sekä asettaa self.tuen_tyyppi arvoksi 1'''
leveys = 15 #nuolen leveus pikseleissä
korkeus = 30 #nuuolen korkeus pikseleissä
'''Nuolen kärkien koordinaatit'''
nuoli_piste_1 = QtCore.QPointF(305, 275)
nuoli_piste_2 = QtCore.QPointF(305 - leveys, 275 + korkeus)
nuoli_piste_3 = QtCore.QPointF(305 + leveys, 275 + korkeus)
nuoli_piste_4 = QtCore.QPointF(995, 275)
nuoli_piste_5 = QtCore.QPointF(995 - leveys, 275 + korkeus)
nuoli_piste_6 = QtCore.QPointF(995 + leveys, 275 + korkeus)
'''Luodaan nuolia kuvaavat QPolygonF oliot'''
self.nuoli_4 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_1, nuoli_piste_2, nuoli_piste_3]))
self.nuoli_5 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_4, nuoli_piste_5, nuoli_piste_6]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
'''Lisätään nuolet sceneen'''
self.scene.addItem(self.nuoli_4)
self.scene.addItem(self.nuoli_5)
self.nuoli_4.hide()
self.nuoli_5.hide()
tyyppi = 1
Ominaisuudet.tuki(self, tyyppi)
self.simuloi.setEnabled(True)
def lisaa_ulkoinen_voima_nappi(self):
'''Luo Lisää ulkoinen voima -napin'''
self.lisaa_ulkoinen_voima = QPushButton("Lisää ulkoinen voima")
self.lisaa_ulkoinen_voima.setToolTip("Lisää ulkoinen voima")
self.lisaa_ulkoinen_voima.move(
0, 2 * self.button_height + 2 * self.button_separation)
self.lisaa_ulkoinen_voima.resize(self.button_width, self.button_height)
self.lisaa_ulkoinen_voima.font = QtGui.QFont()
self.lisaa_ulkoinen_voima.font.setPointSize(8)
self.lisaa_ulkoinen_voima.setFont(self.lisaa_ulkoinen_voima.font)
self.lisaa_ulkoinen_voima.clicked.connect(self.nayta_ulkoinen_voima)
self.lisaa_ulkoinen_voima.clicked.connect(self.nollaa_gradientti)
self.lisaa_ulkoinen_voima.setEnabled(False)
self.scene.addWidget(self.lisaa_ulkoinen_voima)
def poista_ulkoinen_voima_nappi(self):
'''Luo poista ulkoinen voima -napin'''
self.poista_ulkoinen_voima = QPushButton("Poista ulkoinen voima")
self.poista_ulkoinen_voima.setToolTip("Poista ulkoinen voima")
self.poista_ulkoinen_voima.move(
0, 2 * self.button_height + 2 * self.button_separation)
self.poista_ulkoinen_voima.resize(self.button_width,
self.button_height)
self.poista_ulkoinen_voima.setFont(self.lisaa_ulkoinen_voima.font)
self.poista_ulkoinen_voima.clicked.connect(self.piilota_ulkoinen_voima)
self.poista_ulkoinen_voima.clicked.connect(self.nollaa_gradientti)
self.scene.addWidget(self.poista_ulkoinen_voima)
self.poista_ulkoinen_voima.hide()
def piilota_ulkoinen_voima(self):
'''Piilotaa kaiken ulkoiseen voimaan liittyvän'''
self.sp_voima.hide()
self.yksikko_voima.hide()
self.ulkoinen_voima.hide()
self.lisaa_ulkoinen_voima.show()
self.lisaa_ulkoinen_voima.setEnabled(True)
self.viiva.hide()
self.nuoli_3.hide()
self.viiva_5.hide()
self.nuoli_6.hide()
self.poista_ulkoinen_voima.hide()
self.lisaa_ulkoinen_voima.show()
self.tulos.hide()
Ominaisuudet.ulkoinen_voima(self, 0)
def nayta_ulkoinen_voima(self):
'''Näytetään ulkoinen voima riippuen tuen tyypistä'''
self.sp_voima.show()
self.yksikko_voima.show()
self.ulkoinen_voima.show()
self.lisaa_ulkoinen_voima.hide()
self.poista_ulkoinen_voima.show()
if int(Ominaisuudet.palauta_tuen_tyyppi(self)) == 0:
self.viiva.show()
self.nuoli_3.show()
if int(Ominaisuudet.palauta_tuen_tyyppi(self)) == 1:
self.viiva_5.show()
self.nuoli_6.show()
Ominaisuudet.ulkoinen_voima(self, 1)
def ulkoinen_voima_valikko(self):
'''Luo voiman suuruus -tekstin'''
self.ulkoinen_voima = QGraphicsSimpleTextItem("Voiman suuruus")
self.ulkoinen_voima.setPos(600, 5)
self.ulkoinen_voima.font = QtGui.QFont()
self.ulkoinen_voima.font.setPointSize(12)
self.ulkoinen_voima.setFont(self.ulkoinen_voima.font)
self.lisaa_ulkoinen_voima.setEnabled(False)
self.scene.addItem(self.ulkoinen_voima)
self.ulkoinen_voima.hide()
'''Luo voiman arvon QSpinBoxin'''
self.sp_voima = QSpinBox()
self.sp_voima.move(750, 5)
self.sp_voima.setRange(0, 10000)
self.sp_voima.setSingleStep(1)
self.sp_voima.setMinimumHeight(30)
self.sp_voima.setValue(int(Ominaisuudet.palauta_voima(self)))
self.sp_voima.valueChanged.connect(self.paivita_voima)
self.scene.addWidget(self.sp_voima)
self.sp_voima.hide()
'''Luo yksikönvalinta QComboBOxin'''
self.yksikko_voima = QComboBox()
self.yksikko_voima.addItem("kN", 0)
self.yksikko_voima.addItem("N", 1)
self.yksikko_voima.move(820, 5)
self.yksikko_voima.setMinimumHeight(30)
self.yksikko_voima.setCurrentIndex(
int(Ominaisuudet.palauta_voiman_yksikko(self)))
self.yksikko_voima.setEditable(True)
self.yksikko_voima.lineEdit().setAlignment(QtCore.Qt.AlignCenter)
self.scene.addWidget(self.yksikko_voima)
self.yksikko_voima.currentIndexChanged.connect(
self.paivita_yksikko_voima)
self.yksikko_voima.hide()
def ulkoinen_voima_nuoli_seinatuki(self):
'''Luo nuolen osoittamaan ulkoisen voiman paikkaa'''
voima_viiva = QtGui.QPen(QtCore.Qt.black, 2)
voima_viiva.setStyle(QtCore.Qt.SolidLine)
'''Nuolen kärkien koordinaatit seinätuelle'''
nuoli_piste_1 = QtCore.QPointF(self.palkin_paatypiste - 7, 185)
nuoli_piste_2 = QtCore.QPointF(self.palkin_paatypiste, 200)
nuoli_piste_3 = QtCore.QPointF(self.palkin_paatypiste + 7, 185)
viiva_x = self.palkin_paatypiste
self.viiva = QGraphicsLineItem(
QtCore.QLineF(viiva_x, 100, viiva_x, 200))
'''Luodaan nuoli QPolygonItem olio'''
self.nuoli_3 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_1, nuoli_piste_2, nuoli_piste_3]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
'''Lisätään viiva sekä päiden nuolet sceneen'''
self.scene.addItem(self.viiva)
self.scene.addItem(self.nuoli_3)
self.viiva.hide()
self.nuoli_3.hide()
'''Lisätään tieto, että voima on asetettu'''
Ominaisuudet.ulkoinen_voima(self, 1)
def ulkoinen_voima_nuoli_alatuki(self):
'''Nuolen kärkien koordinaatit alhaalta tuetulle palkille'''
nuoli_piste_1 = QtCore.QPointF(self.palkin_keskipiste - 7, 185)
nuoli_piste_2 = QtCore.QPointF(self.palkin_keskipiste, 200)
nuoli_piste_3 = QtCore.QPointF(self.palkin_keskipiste + 7, 185)
viiva_x = self.palkin_keskipiste
'''Luodaan nuoli QPolygonItem olio'''
self.nuoli_6 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_1, nuoli_piste_2, nuoli_piste_3]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
self.viiva_5 = QGraphicsLineItem(
QtCore.QLineF(viiva_x, 100, viiva_x, 200))
'''Lisätään viiva sekä päiden nuolet sceneen'''
self.scene.addItem(self.viiva_5)
self.scene.addItem(self.nuoli_6)
self.viiva_5.hide()
self.nuoli_6.hide()
'''Lisätään tieto, että voima on asetettu'''
Ominaisuudet.ulkoinen_voima(self, 1)
def paivita_voima(self):
'''Lukee voiman arvon
ja kutsuu Ominaisuudet luoka metodia voima'''
voima = self.sp_voima.value()
Ominaisuudet.voima(self, voima)
def paivita_yksikko_voima(self):
'''Lukee ykiskön arvon
ja kutsuu Ominaisuudet-luokan metodia yksikko_voima'''
self.yksikko_voima_arvo = self.yksikko_voima.currentData()
Ominaisuudet.yksikko_voima(self, self.yksikko_voima_arvo)
def materiaali_valikko(self):
''' Luo Materiaali-otsikon'''
self.materiaali = QGraphicsSimpleTextItem("Materiaali")
self.materiaali.setPos(
0, 3 * self.button_height + 3 * self.button_separation)
self.materiaali.font = QtGui.QFont()
self.materiaali.font.setPointSize(12)
self.materiaali.setFont(self.materiaali.font)
self.scene.addItem(self.materiaali)
'''Luo drop down valikon materiaalivalinnalle'''
self.materiaali_valinta = QComboBox()
self.materiaali_valinta.addItem("Teräs", 0)
self.materiaali_valinta.addItem("Alumiini", 1)
self.materiaali_valinta.addItem("Muovi", 2)
self.materiaali_valinta.move(
0, 3 * self.button_height + 3 * self.button_separation + 25)
self.materiaali_valinta.resize(self.button_width,
self.button_height - 25)
self.materiaali_valinta.setEditable(True)
self.materiaali_valinta.lineEdit().setAlignment(QtCore.Qt.AlignCenter)
self.materiaali_valinta.setCurrentIndex(0)
self.scene.addWidget(self.materiaali_valinta)
self.materiaali_valinta.setEnabled(False)
self.materiaali_valinta.currentIndexChanged.connect(
self.paivita_materiaali)
def paivita_materiaali(self):
'''Lukee materiaalin arvon
ja kutsuu Ominaisuudet-luokan metodia materiaali'''
materiaali = self.materiaali_valinta.currentData()
Ominaisuudet.materiaali(self, materiaali)
def simulaatio_nappi(self):
'''Luo SIMULOI-napin'''
self.simuloi = QPushButton('SIMULOI')
self.simuloi.setToolTip('Simuloi valittu rakenne')
self.simuloi.move(0,
4 * self.button_height + 4 * self.button_separation)
self.simuloi.setStyleSheet("background-color:rgb(122, 201, 255)")
self.simuloi.resize(self.button_width, self.button_height)
self.simuloi.font = QtGui.QFont()
self.simuloi.font.setPointSize(12)
self.simuloi.setFont(self.simuloi.font)
self.simuloi.setEnabled(False)
self.simuloi.clicked.connect(self.simulaatio)
self.scene.addWidget(self.simuloi)
def simulaatio(self):
'''Kutsuu laskentaa suorittavaa metodia ja tallentaa tuloksen.
Tämän jälkeen kutsuu lopputuloksen esittävän tekstin päivittävää metodia
sekä palkin visualisoivaa gradient-metodia'''
Laskin.laskin(self)
Ominaisuudet.palauta_tulos(self)
self.paivita_tulos_teksti()
self.tallennaAction.setEnabled(True)
if Ominaisuudet.palauta_tuen_tyyppi(self) == 0:
if Ominaisuudet.onko_ulkoinen_voima_asetettu(self) == 1:
self.gradient_seina_tuki()
if Ominaisuudet.onko_ulkoinen_voima_asetettu(self) == 0:
self.gradient_seina_tuki_ei_voimaa()
if Ominaisuudet.palauta_tuen_tyyppi(self) == 1:
self.gradient_alatuki()
def tulos_teksti(self):
'''Lisää tekstin, joka kertoo maksimijänintyksen arvon'''
teksti = "Maksimijännitys " + str(self.maks_jannitys) + " MPa"
self.tulos = QGraphicsSimpleTextItem(teksti)
self.tulos.setPos(550, 500)
self.tulos.font = QtGui.QFont()
self.tulos.font.setPointSize(12)
self.tulos.setFont(self.tulos.font)
self.scene.addItem(self.tulos)
self.tulos.hide()
def paivita_tulos_teksti(self):
'''Päivittää maksimijännityksen arvoa kuvaavan tekstin'''
maks_jannitys = Ominaisuudet.palauta_tulos(self)
self.tulos.setText("Maksimijännitys " + str(maks_jannitys) + " MPa")
self.tulos.show()
def palkin_pituus_valikko(self):
'''Luo palkin pituus tekstin sekä spinbox-valitsimen pituuden asettamista varten
Päivittää palkin pituuden Ominaisuudet luokan avulla'''
self.palkin_pituus = QGraphicsSimpleTextItem("Palkin pituus")
self.palkin_pituus.setPos(300, 5)
self.palkin_pituus.font = QtGui.QFont()
self.palkin_pituus.font.setPointSize(12)
self.palkin_pituus.setFont(self.palkin_pituus.font)
self.scene.addItem(self.palkin_pituus)
self.palkin_pituus.hide()
self.sp = QSpinBox()
self.scene.addWidget(self.sp)
self.sp.hide()
self.sp.move(450, 5)
self.sp.setRange(0, 100)
self.sp.setSingleStep(1)
self.sp.setMinimumHeight(30)
self.sp.setValue(int(Ominaisuudet.palauta_palkin_pituus(self)))
self.paivita_pituus()
self.sp.valueChanged.connect(self.paivita_pituus)
def paivita_pituus(self):
'''Lukee palkin pituuden ja aktivoi Ominaisuudet luokan meodin palkin pituus'''
self.palkin_pituus_arvo = self.sp.value()
Ominaisuudet.palkin_pituus(self, self.palkin_pituus_arvo)
self.paivita_asteikon_arvot()
def yksikko_pituus(self):
'''Luo yksikönvalinta dropdown-menun
ja arvon muuttuessa päivittää yksikön Ominaisuudet-luokassa'''
self.yksikko = QComboBox()
self.yksikko.addItem("m", 0)
self.yksikko.addItem("cm", 1)
self.yksikko.addItem("mm", 2)
self.yksikko.move(500, 5)
self.yksikko.setMinimumHeight(30)
self.yksikko.setEditable(True)
self.yksikko.lineEdit().setAlignment(QtCore.Qt.AlignCenter)
self.yksikko.setCurrentIndex(
Ominaisuudet.palauta_pituuden_yksikko(self))
self.scene.addWidget(self.yksikko)
self.yksikko.hide()
self.yksikko_arvo = self.yksikko.currentData()
self.yksikko.currentIndexChanged.connect(self.paivita_yksikko)
def paivita_yksikko(self):
'''Lukee yksikön arvon
ja kutsuu Ominaisuudet-luokan metodia yksikko'''
self.yksikko_arvo = self.yksikko.currentData()
Ominaisuudet.yksikko(self, self.yksikko_arvo)
self.paivita_asteikon_arvot()
def asteikko(self):
''''Luodaan viivaa kuvaava olio'''
viiva = QtGui.QPen(QtCore.Qt.black, 2)
viiva.setStyle(QtCore.Qt.SolidLine)
'''Oikean puoleisen nuolen kärkien koordinaatit'''
nuoli_1_piste_1 = QtCore.QPointF(990, 390)
nuoli_1_piste_2 = QtCore.QPointF(1000, 400)
nuoli_1_piste_3 = QtCore.QPointF(990, 410)
'''Vasemman puoleisen nuolen kärkien koordinaatit'''
nuoli_2_piste_1 = QtCore.QPointF(310, 390)
nuoli_2_piste_2 = QtCore.QPointF(300, 400)
nuoli_2_piste_3 = QtCore.QPointF(310, 410)
'''Luodaan nuoli QPolygonF oliot'''
self.nuoli_1 = QGraphicsPolygonItem(
QtGui.QPolygonF(
[nuoli_1_piste_1, nuoli_1_piste_2, nuoli_1_piste_3]))
self.nuoli_2 = QGraphicsPolygonItem(
QtGui.QPolygonF(
[nuoli_2_piste_1, nuoli_2_piste_2, nuoli_2_piste_3]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
self.line = QGraphicsLineItem(QtCore.QLineF(300, 400, 1000, 400))
'''Lisätään viiva sekä päiden nuolet sceneen'''
self.scene.addItem(self.line)
self.scene.addItem(self.nuoli_1)
self.scene.addItem(self.nuoli_2)
self.line.hide()
self.nuoli_1.hide()
self.nuoli_2.hide()
def lisaa_asteikko_arvo(self):
'''Lisää tekstikentän pituuden arvolle sekä yksikölle'''
teksti = (str(Ominaisuudet.palauta_palkin_pituus(self)) + " " + "m")
self.asteikko_teksti = QGraphicsSimpleTextItem()
self.asteikko_teksti.setText(teksti)
self.asteikko_teksti.setPos(650, 425)
self.asteikko_teksti.font = QtGui.QFont()
self.asteikko_teksti.font.setPointSize(12)
self.asteikko_teksti.setFont(self.asteikko_teksti.font)
self.scene.addItem(self.asteikko_teksti)
self.asteikko_teksti.hide()
def paivita_asteikon_arvot(self):
'''Päivittää palkin pituutta kuvaavan asteikon'''
yksikko = Ominaisuudet.palauta_pituuden_yksikko(self)
if yksikko == 0:
self.yksikko_merkki = "m"
if yksikko == 1:
self.yksikko_merkki = "cm"
if yksikko == 2:
self.yksikko_merkki = "mm"
pituus = float(Ominaisuudet.palauta_palkin_pituus(self))
teksti = str(str(pituus) + " " + self.yksikko_merkki)
self.asteikko_teksti.setText(teksti)
self.asteikko_teksti.show()
def gradient_seina_tuki(self):
'''Luo seinästä tuetun palkin rasitusta kuvaavan gradientin'''
gradient = QLinearGradient(300, 200, 300 + self.palkin_leveys, 200)
gradient.setColorAt(0, QColor(244, 72, 66))
gradient.setColorAt(1, QColor(65, 244, 83))
self.rect.setBrush(gradient)
def gradient_seina_tuki_ei_voimaa(self):
'''Luo ilman ulkoista voimaa olevan gradientin'''
gradient = QLinearGradient(300, 200, 300 + (self.palkin_leveys / 2),
200)
gradient.setColorAt(0, QColor(244, 72, 66))
gradient.setColorAt(1, QColor(65, 244, 83))
self.rect.setBrush(gradient)
def gradient_alatuki(self):
'''Luo kahdella alatuella olevan palkin rasitusta kuvaavan gradientin'''
gradient = QLinearGradient(300, 200, 300 + self.palkin_leveys, 200)
gradient.setColorAt(0, QColor(65, 244, 83))
gradient.setColorAt(0.5, QColor(244, 72, 66))
gradient.setColorAt(1, QColor(65, 244, 83))
self.rect.setBrush(gradient)
def nollaa_gradientti(self):
'''Asettaa palkin "normaaliksi"'''
self.rect.setBrush(QBrush(4))
def uusi_rakenne(self):
'''Muokkaa ikkunaa uuden simulaation luomista varten'''
self.rect.hide()
self.ulkoinen_voima.hide()
self.sp_voima.hide()
self.yksikko_voima.hide()
self.nuoli_1.hide()
self.nuoli_2.hide()
self.nuoli_3.hide()
self.nuoli_4.hide()
self.nuoli_5.hide()
self.nuoli_6.hide()
self.viiva_1.hide()
self.viiva_2.hide()
self.viiva_3.hide()
self.viiva_4.hide()
self.viiva_5.hide()
self.viiva.hide()
self.palkin_pituus.hide()
self.sp.hide()
self.yksikko.hide()
self.line.hide()
self.asteikko_teksti.hide()
self.tulos.hide()
self.nollaa_gradientti()
self.lisaa_tuki.show()
self.vaihda_tuki.hide()
self.poista_ulkoinen_voima.hide()
self.lisaa_ulkoinen_voima.show()
Ominaisuudet.alkuarvot(self)
'''Asettaa napit'''
self.uusi_palkki.setEnabled(True)
self.lisaa_ulkoinen_voima.setEnabled(False)
self.lisaa_tuki.setEnabled(False)
self.simuloi.setEnabled(False)
self.tallennaAction.setEnabled(False)
'''Päivittää tuen tyypiksi arvon, joka vastaa, ettei tukea ole'''
self.tuen_tyyppi = 2
def close_application(self):
'''sulkee ohjelman'''
sys.exit()
