class PrvTreeviewNest(QTreeView):
def __init__(self):
super(PrvTreeviewNest, self).__init__()
loadUi('/home/user/yourproject/resource/treeview_nest.ui')
# row can be 0 even when it's more than 0.
self._datamodel = QStandardItemModel(0, 2)
self.setModel(self._datamodel)
for i in range(4):
self._add_widget(i + 1)
self.show()
def _add_widget(self, n):
item_toplevel = QStandardItem('{}th item'.format(n))
self._datamodel.setItem(n, 0, item_toplevel)
widget_toplevel = QPushButton('{}th button'.format(n))
qindex_toplevel = self._datamodel.index(n, 1, QModelIndex())
self.setIndexWidget(qindex_toplevel, widget_toplevel)
if n == 2:
item_child_col0 = QStandardItem('child col0')
item_child_col1 = QStandardItem('child col1')
#item_toplevel.appendRow(item_child_col0)
item_toplevel.insertRow(0, [item_child_col0, item_child_col1])
widget_child = QPushButton('child widget')
qindex_child = item_child_col1.index()
self.setIndexWidget(qindex_child, widget_child)
def actualizePeakModelComparative():
model = QStandardItemModel()
#root=MSDialogController.getColouredRootItem(sample)
sampleList = QApplication.instance().model
groups = sampleList.peaksGrouping()
model.setVerticalHeaderLabels([
"/".join(map(str,
round([mass, rt], 4).tolist()))
for mass, rt in sorted(groups.keys(), key=lambda x: x[0])
])
model.setHorizontalHeaderLabels(
[spl.shortName() for spl in sampleList.isamples()])
for i, key in enumerate(sorted(groups.keys(), key=lambda x: x[0])):
zeros = [0.] * len(sampleList)
for peak in groups[key]:
try:
idx = [spl.shortName() for spl in sampleList
].index(peak.sample.shortName())
except ValueError:
print "Error in %s" % MSDialogController.actualizePeakModelComparative.__name__
zeros[idx] = peak
for j in xrange(len(zeros)):
item = QStandardItem()
if not zeros[j]:
item.setBackground(QBrush(Qt.red))
item.setText("Not found")
else:
MSDialogController.setRightIcon(
zeros[j], item) #set the colour actually
item.setText(str(round(zeros[j].area, 2)))
model.setItem(i, j, item)
return model
class Gestion_Combobox_domaine_Thread(QRunnable):
# signalmodel_dispo = pyqtSignal(QStandardItemModel)
def __init__(self, engine):
QThread.__init__(self)
self.signals = WorkerSignals()
# self.combobox = combobox
self.engine = engine
# def __del__(self):
# self.wait()
def run(self):
"""rempli le combobox domaine et cree la possibilité de checked des items"""
init_domaine = Insertion_Domaine(self.engine)
areas = init_domaine.recuperation_domaine()
self.model = QStandardItemModel((len(areas) + 1), 1) # 5 rows, 1 col
firstItem = QStandardItem("---- Select domaine(s) ----")
firstItem.setBackground(QBrush(QColor(200, 200, 200)))
firstItem.setSelectable(False)
self.model.setItem(0, 0, firstItem)
for i, area in enumerate(areas):
item = QStandardItem(area)
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setData(Qt.Unchecked, Qt.CheckStateRole)
self.model.setItem(i + 1, 0, item)
self.signals.signalmodel_dispo.emit(self.model)
def actualizePeakModelComparative():
model = QStandardItemModel()
#root=MSDialogController.getColouredRootItem(sample)
sampleList = QApplication.instance().model
groups = sampleList.peaksGrouping()
model.setVerticalHeaderLabels(["/".join(map(str, round([mass, rt], 4).tolist())) for mass, rt in sorted(groups.keys(), key=lambda x:x[0])])
model.setHorizontalHeaderLabels([spl.shortName() for spl in sampleList.isamples()])
for i, key in enumerate(sorted(groups.keys(), key=lambda x:x[0])):
zeros = [0.] * len(sampleList)
for peak in groups[key]:
try:
idx = [spl.shortName() for spl in sampleList].index(peak.sample.shortName())
except ValueError:
print "Error in %s"%MSDialogController.actualizePeakModelComparative.__name__
zeros[idx] = peak
for j in xrange(len(zeros)):
item = QStandardItem()
if not zeros[j]:
item.setBackground(QBrush(Qt.red))
item.setText("Not found")
else:
MSDialogController.setRightIcon(zeros[j], item)#set the colour actually
item.setText(str(round(zeros[j].area, 2)))
model.setItem(i, j, item)
return model
class PrvTreeviewNest(QTreeView):
def __init__(self):
super(PrvTreeviewNest, self).__init__()
loadUi('treeview_nest.ui')
# row can be 0 even when it's more than 0.
self._datamodel = QStandardItemModel(0, 2)
self.setModel(self._datamodel)
for i in range(4):
self.add_widget(i + 1)
self.show()
def add_widget(self, n):
std_item = QStandardItem('{}th item'.format(n))
self._datamodel.setItem(n, 0, std_item)
node_widget = QPushButton('{}th button'.format(n))
qindex_widget = self._datamodel.index(n, 1, QModelIndex())
self.setIndexWidget(qindex_widget, node_widget)
if n == 2:
std_item_child = QStandardItem('child')
std_item.appendRow(std_item_child)
node_widget_child = QPushButton('petit button')
qindex_widget_child = self._datamodel.index(n, 1, QModelIndex())
self.setIndexWidget(qindex_widget_child, node_widget_child)
class PrvTreeviewNest(QTreeView):
def __init__(self):
super(PrvTreeviewNest, self).__init__()
loadUi('treeview_nest.ui')
# row can be 0 even when it's more than 0.
self._datamodel = QStandardItemModel(0, 2)
self.setModel(self._datamodel)
for i in range(4):
self.add_widget(i + 1)
self.show()
def add_widget(self, n):
std_item = QStandardItem('{}th item'.format(n))
self._datamodel.setItem(n, 0, std_item)
node_widget = QPushButton('{}th button'.format(n))
qindex_widget = self._datamodel.index(n, 1, QModelIndex())
self.setIndexWidget(qindex_widget, node_widget)
if n == 2:
std_item_child = QStandardItem('child')
std_item.appendRow(std_item_child)
node_widget_child = QPushButton('petit button')
qindex_widget_child = self._datamodel.index(n, 1, QModelIndex())
self.setIndexWidget(qindex_widget_child, node_widget_child)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
uic.loadUi("mainwindow.ui", self)
model = QStandardItemModel(7, 4, self)
for row in range(7):
for column in range(4):
item = QStandardItem(QString("%1").arg(row * 4 + column))
model.setItem(row, column, item)
self.tableView = QTableView()
self.tableView.setModel(model)
self.setCentralWidget(self.tableView)
# 获取视图的项目选择模型
selectionModel = self.tableView.selectionModel()
# 定义左上角和右下角的索引，然后使用这两个索引创建选择
topLeft = model.index(1, 1, QModelIndex())
bottomRight = model.index(5, 2, QModelIndex())
selection = QItemSelection(topLeft, bottomRight)
# 使用指定的选择模式来选择项目
selectionModel.select(selection, QItemSelectionModel.Select)
self.mainToolBar.addAction(_fromUtf8("当前项目"), self.getCurrentItemData)
self.mainToolBar.addAction(_fromUtf8("切换选择"), self.toggleSelection)
def __display_table_rslt(self, table_rows):
'''
controls table_comp_rslt widget
fill the widget with table_rows list
@param table_rows: []
'''
rows_count = len(table_rows)
model = QStandardItemModel(rows_count, 3)
model.setHorizontalHeaderLabels(TAB_LABELS)
# fill model with data
for row in range(rows_count):
for col in range(3):
item = QStandardItem()
item.setData(str(table_rows[row][col]), Qt.DisplayRole)
model.setItem(row, col, item)
# self.table_comp_rslt.clearContents()
if self.table_comp_rslt.isSortingEnabled():
self.table_comp_rslt.setSortingEnabled(False)
proxy = numsort.NumberSortModel()
proxy.setSourceModel(model)
self.table_comp_rslt.setModel(proxy)
self.table_comp_rslt.resizeColumnsToContents()
self.table_comp_rslt.setSortingEnabled(True)
def makeModel(self, results, index = 2):
getAttr = [lambda obj: obj.name,
lambda obj: obj.size[0]*(1024**obj.size[1]),
lambda obj: obj.seed,
lambda obj: obj.leach]
col = len(results)
ascending = False if index == self.currentColumnSort[0] and self.currentColumnSort[1] else True
self.currentColumnSort = [index, ascending]
model = QStandardItemModel(col, 4, self)
columnHeaderItems = [QStandardItem(column) for column in "Name", "Size", "Seeds", "Leachs"]
columnHeaderItems[index].setIcon(self.ascendingIcon if ascending else self.descendingIcon)
for i in range(4):
model.setHorizontalHeaderItem(i, columnHeaderItems[i])
if results:
results = list_to_tree(results, lambda x, y: getAttr[index](x) > getAttr[index](y))
if ascending: results = results.postOrder()
else: results = results.preOrder()
self.results = results
for i in range(col):
result = results[i]
size = from_bit_to(result.size[0]*1024**result.size[1])
model.setItem(i, 0, QStandardItem(result.name))
model.setItem(i, 1, QStandardItem(size))
model.setItem(i, 2, QStandardItem(str(result.seed)))
model.setItem(i, 3, QStandardItem(str(result.leach)))
return model
def populateTable(self, table):
cols = len(self.param.cols)
rows = len(table)
model = QStandardItemModel(rows, cols)
# Set headers
model.setHorizontalHeaderLabels(self.param.cols)
# Populate table
for i in xrange(rows):
for j in xrange(cols):
item = QStandardItem(table[i][j])
model.setItem(i, j, item)
self.tblView.setModel(model)
def populateTable(self, table):
cols = len(self.param.cols)
rows = len(table)
model = QStandardItemModel(rows, cols)
# Set headers
model.setHorizontalHeaderLabels(self.param.cols)
# Populate table
for i in xrange(rows):
for j in xrange(cols):
item = QStandardItem(table[i][j])
model.setItem(i, j, item)
self.tblView.setModel(model)
def initialize_buckets_table(self):
self.storj_engine = StorjEngine() # init StorjEngine
logger.info("resolving buckets")
model = QStandardItemModel(1, 1) # initialize model for inserting to table
model.setHorizontalHeaderLabels(['Name', 'Storage', 'Transfer', 'ID'])
i = 0
try:
for bucket in self.storj_engine.storj_client.bucket_list():
item = QStandardItem(bucket.name)
model.setItem(i, 0, item) # row, column, item (QStandardItem)
item = QStandardItem(str(bucket.storage))
model.setItem(i, 1, item) # row, column, item (QStandardItem)
item = QStandardItem(str(bucket.transfer))
model.setItem(i, 2, item) # row, column, item (QStandardItem)
item = QStandardItem(bucket.id)
model.setItem(i, 3, item) # row, column, item (QStandardItem)
i = i + 1
except sjexc.StorjBridgeApiError as e:
QtGui.QMessageBox.about(
self,
'Unhandled bucket resolving exception',
'Exception: %s' % e)
self.bucket_manager_ui.total_buckets_label.setText(str(i)) # set label of user buckets number
self.bucket_manager_ui.bucket_list_tableview.setModel(model)
self.bucket_manager_ui.bucket_list_tableview.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch)
def populate_columns_list(self):
"""
Populate the columns view.
:return:
:rtype:
"""
options = {}
options['type'] = 'combobox'
delegate = GenericDelegate(
self.separators, options, self.column_code_view)
# Set delegate to add widget
self.column_code_view.setItemDelegate(
delegate
)
self.column_code_view.setItemDelegateForColumn(
1, delegate
)
model = QStandardItemModel(2, 2)
i = 0
for row, col in enumerate(self._columns):
column_item = QStandardItem(self._entity.columns[col].header())
column_item.setCheckable(True)
model.setItem(i, 0, column_item)
column_item.setData(col)
self.column_code_view.setModel(model)
i = i + 1
for col in self._entity.columns.values():
if col.name == 'id':
continue
if col.name not in self._columns:
# Correct row by reducing by one due to removal of id
column_item = QStandardItem(col.header())
column_item.setCheckable(True)
model.setItem(i, 0, column_item)
column_item.setData(col.name)
self.column_code_view.setModel(model)
i = i + 1
def buildModel(self, choosenOne):
identificationModel = QStandardItemModel()
if choosenOne.formulas:
identificationModel.setHorizontalHeaderLabels(["score", "formula", "diff mass", "names"])
for i, f in enumerate(choosenOne.formulas.iterkeys()):
identificationModel.setItem(i, 0, MSStandardItem(str(choosenOne.formulas[f]["score"])))
identificationModel.setItem(i, 1, QStandardItem(str(f)))
identificationModel.setItem(i, 2, MSStandardItem(str(choosenOne.formulas[f]["diffmass"])))
identificationModel.setItem(i, 3, QStandardItem(choosenOne.formulas[f]["names"]))
return identificationModel
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
uic.loadUi("mainwindow.ui", self)
model = QStandardItemModel(7, 4, self)
for row in range(7):
for column in range(4):
item = QStandardItem(QString("%1").arg(row * 4 + column))
model.setItem(row, column, item)
self.tableView = QTableView()
self.tableView.setModel(model)
self.setCentralWidget(self.tableView)
# 获取视图的项目选择模型
selectionModel = self.tableView.selectionModel()
# 定义左上角和右下角的索引，然后使用这两个索引创建选择
topLeft = model.index(1, 1, QModelIndex())
bottomRight = model.index(5, 2, QModelIndex())
selection = QItemSelection(topLeft, bottomRight)
# 使用指定的选择模式来选择项目
selectionModel.select(selection, QItemSelectionModel.Select)
self.mainToolBar.addAction(_fromUtf8("当前项目"), self.getCurrentItemData)
self.mainToolBar.addAction(_fromUtf8("切换选择"), self.toggleSelection)
self.connect(selectionModel,SIGNAL("selectionChanged(QItemSelection,QItemSelection)"),
self.updateSelection)
self.connect(selectionModel, SIGNAL("currentChanged(QModelIndex,QModelIndex)"),
self.changeCurrent)
# 多个视图共享选择
self.tableView2 = QTableView()
self.tableView2.setWindowTitle("tableView2")
self.tableView2.resize(400, 300)
self.tableView2.setModel(model)
self.tableView2.setSelectionModel(selectionModel)
self.tableView2.show()
# 使用自定义委托
delegate = SpinBoxDelegate(self)
self.tableView.setItemDelegate(delegate)
class PrvTreeviewNest(QTreeView):
def __init__(self):
super(PrvTreeviewNest, self).__init__()
rp = rospkg.RosPack()
ui_file = os.path.join(rp.get_path('rqt_prove'),
'resource', 'treeview_nest.ui')
loadUi(ui_file, self)
#loadUi('/home/n130s/data/Dropbox/ROS/groovy_quantal/catkin_ws/src/' + \
#'rqt_prove/resource/treeview_nest.ui')
# row can be 0 even when it's more than 0.
self._datamodel = QStandardItemModel(0, 2)
self.setModel(self._datamodel)
for i in range(4):
self._add_widget(i + 1)
self.show()
def _add_widget(self, n):
item_toplevel = QStandardItem('{}th item'.format(n))
self._datamodel.setItem(n, 0, item_toplevel)
widget_toplevel = QPushButton('{}th button'.format(n))
qindex_toplevel = self._datamodel.index(n, 1, QModelIndex())
self.setIndexWidget(qindex_toplevel, widget_toplevel)
if n == 2:
item_child_col0 = QStandardItem('child col0')
item_child_col1 = QStandardItem('child col1')
#item_toplevel.appendRow(item_child_col0)
item_child_col2 = QStandardItem('child col2')
item_toplevel.insertRow(0, [item_child_col0, item_child_col1])
#item_child_col0.insertColumn(0, [item_child_col1, item_child_col2])
#item_child_col0.appendColumn([item_child_col1]) # appends another child
widget_child = QPushButton('child widget')
#qindex_child = self._datamodel.index(n, 1, QModelIndex())
qindex_child = item_child_col1.index()
#qindex_child = item_toplevel.index(0, 1, QModelIndex())
self.setIndexWidget(qindex_child, widget_child)
def update(self):
model = QStandardItemModel()
model.setHorizontalHeaderItem(0, QStandardItem(i18n.get('account')))
model.setHorizontalHeaderItem(1, QStandardItem(i18n.get('message')))
self.list_.setModel(model)
now = int(time.time())
interval = self.base.core.get_queue_interval() * 60
if self.last_timestamp:
est_time = ((self.last_timestamp + interval) - now) / 60
else:
est_time = 0
row = 0
for status in self.base.core.list_statuses_queue():
username = get_username_from(status.account_id)
protocol_image = "%s.png" % get_protocol_from(status.account_id)
item = QStandardItem(QString.fromUtf8(username))
item.setIcon(QIcon(self.base.load_image(protocol_image, True)))
model.setItem(row, 0, item)
model.setItem(row, 1, QStandardItem(QString.fromUtf8(status.text)))
row += 1
humanized_interval = self.base.humanize_time_intervals(
self.base.core.get_queue_interval())
humanized_est_time = self.base.humanize_time_intervals(est_time)
warning = i18n.get('messages_will_be_send') % humanized_interval
next_message = ' '.join(
[i18n.get('next_message_should_be_posted_in'), humanized_est_time])
self.caption.setText(warning)
if row == 0:
self.estimated_time.setText('')
else:
self.estimated_time.setText(next_message)
self.list_.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.list_.resizeColumnsToContents()
self.__enable()
def update(self):
model = QStandardItemModel()
model.setHorizontalHeaderItem(0, QStandardItem(i18n.get('account')))
model.setHorizontalHeaderItem(1, QStandardItem(i18n.get('message')))
self.list_.setModel(model)
now = int(time.time())
interval = self.base.core.get_queue_interval() * 60
if self.last_timestamp:
est_time = ((self.last_timestamp + interval) - now) / 60
else:
est_time = 0
row = 0
for status in self.base.core.list_statuses_queue():
username = get_username_from(status.account_id)
protocol_image = "%s.png" % get_protocol_from(status.account_id)
item = QStandardItem(QString.fromUtf8(username))
item.setIcon(QIcon(self.base.load_image(protocol_image, True)))
model.setItem(row, 0, item)
model.setItem(row, 1, QStandardItem(QString.fromUtf8(status.text)))
row += 1
humanized_interval = self.base.humanize_time_intervals(self.base.core.get_queue_interval())
humanized_est_time = self.base.humanize_time_intervals(est_time)
warning = i18n.get('messages_will_be_send') % humanized_interval
next_message = ' '.join([i18n.get('next_message_should_be_posted_in'), humanized_est_time])
self.caption.setText(warning)
if row == 0:
self.estimated_time.setText('')
else:
self.estimated_time.setText(next_message)
self.list_.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.list_.resizeColumnsToContents()
self.__enable()
class ObstacleTable(QSortFilterProxyModel):
MocMultiplier = 1
SelectionMode = SelectionModeType.Automatic
def __init__(self, surfacesList, fileWriter=None):
QSortFilterProxyModel.__init__(self)
ObstacleTable.SelectionMode = SelectionModeType.Automatic
self.manualPolygon = None
self.surfacesList = surfacesList
self.surfaceType = None
self.source = QStandardItemModel()
self.setSourceModel(self.source)
# tableView.hideColumn(self.IndexObjectId)
# tableView.hideColumn(self.IndexLayerId)
# tableView.hideColumn(self.IndexX)
# tableView.hideColumn(self.IndexY)
# tableView.hideColumn(self.IndexLat)
# tableView.hideColumn(self.IndexLon)
# tableView.hideColumn(self.IndexSurface)
self.hideColumnLabels = [
ObstacleTableColumnType.ObjectId, ObstacleTableColumnType.LayerId,
ObstacleTableColumnType.X, ObstacleTableColumnType.Y,
ObstacleTableColumnType.Lat, ObstacleTableColumnType.Lon,
ObstacleTableColumnType.Surface
]
self.fixedColumnLabels = [
ObstacleTableColumnType.ObjectId, ObstacleTableColumnType.LayerId,
ObstacleTableColumnType.Name, ObstacleTableColumnType.X,
ObstacleTableColumnType.Y, ObstacleTableColumnType.Lat,
ObstacleTableColumnType.Lon, ObstacleTableColumnType.AltM,
ObstacleTableColumnType.AltFt, ObstacleTableColumnType.TreesM,
ObstacleTableColumnType.TreesFt
]
self.IndexObjectId = 0
self.IndexLayerId = 1
self.IndexName = 2
self.IndexX = 3
self.IndexY = 4
self.IndexLat = 5
self.IndexLon = 6
self.IndexAltM = 7
self.IndexAltFt = 8
self.IndexTreesM = 9
self.IndexTreesFt = 10
self.IndexOcaM = -1
self.IndexOcaFt = -1
self.IndexOchM = -1
self.IndexOchFt = -1
self.IndexObstArea = -1
self.IndexDistInSecM = -1
self.IndexMocAppliedM = -1
self.IndexMocAppliedFt = -1
self.IndexMocMultiplier = -1
self.IndexMocReqM = -1
self.IndexMocReqFt = -1
self.IndexDoM = -1
self.IndexDrM = -1
self.IndexDzM = -1
self.IndexDxM = -1
self.IndexDsocM = -1
self.IndexHeightLossM = -1
self.IndexHeightLossFt = -1
self.IndexAcAltM = -1
self.IndexAcAltFt = -1
self.IndexAltReqM = -1
self.IndexAltReqFt = -1
self.IndexCritical = -1
self.IndexMACG = -1
self.IndexPDG = -1
self.IndexSurfAltM = -1
self.IndexSurfAltFt = -1
self.IndexDifferenceM = -1
self.IndexDifferenceFt = -1
self.IndexIlsX = -1
self.IndexIlsY = -1
self.IndexEqAltM = -1
self.IndexEqAltFt = -1
self.IndexSurfaceName = -1
self.IndexDisregardable = -1
self.IndexCloseIn = -1
self.IndexTag = -1
self.IndexSurface = -1
self.IndexArea = -1
self.IndexHLAppliedM = -1
self.setHeaderLabels()
self.setFilterKeyColumn(self.IndexSurface)
self.setSortRole(Qt.UserRole + 1)
self.layoutChanged.connect(self.setVerticalHeader)
self.btnLocate = None
self.tblObstacles = None
def FilterDisregardableObstacles(self, state):
if state:
self.setFilterKeyColumn(self.IndexDisregardable)
self.setFilterFixedString("Yes")
self.setFilterKeyColumn(self.IndexSurface)
def setSurfaceType(self, surfaceType):
self.surfaceType = surfaceType
def setFilterFixedString(self, filterString):
QSortFilterProxyModel.setFilterFixedString(self, filterString)
self.setVerticalHeader()
if self.btnLocate != None and self.tblObstacles != None:
selectedIndexes = self.tblObstacles.selectedIndexes()
if len(selectedIndexes) == 0:
self.btnLocate.setEnabled(False)
else:
self.btnLocate.setEnabled(True)
def setLocateBtn(self, btnLocate):
self.btnLocate = btnLocate
self.btnLocate.setEnabled(False)
self.btnLocate.clicked.connect(self.btnLocateClicked)
def btnLocateClicked(self):
if self.tblObstacles == None:
return
selectedIndexes = self.tblObstacles.selectedIndexes()
self.locate(selectedIndexes)
def tblObstaclesClicked(self, idx):
if len(self.tblObstacles.selectedIndexes()) > 0:
self.btnLocate.setEnabled(True)
def setTableView(self, tblObstacles):
self.tblObstacles = tblObstacles
self.tblObstacles.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tblObstacles.setSortingEnabled(True)
self.tblObstacles.clicked.connect(self.tblObstaclesClicked)
self.tblObstacles.verticalHeader().sectionClicked.connect(
self.tblObstaclesClicked)
pass
def setHeaderLabels(self):
# print self.setHeaderData(1, Qt.Vertical, 1, Qt.DisplayRole)
pass
def setVerticalHeader(self):
for i in range(self.rowCount()):
self.setHeaderData(i, Qt.Vertical, i + 1, Qt.DisplayRole)
def setHiddenColumns(self, tableView):
tableView.hideColumn(self.IndexObjectId)
tableView.hideColumn(self.IndexLayerId)
tableView.hideColumn(self.IndexX)
tableView.hideColumn(self.IndexY)
tableView.hideColumn(self.IndexLat)
tableView.hideColumn(self.IndexLon)
tableView.hideColumn(self.IndexSurface)
def getExtentForLocate(self, sourceRow):
extent = None
surfaceType = None
if self.IndexSurface < 0:
surfaceType = self.surfaceType
else:
surfaceType = self.source.item(sourceRow, self.IndexSurface).text()
surfaceLayers = QgisHelper.getSurfaceLayers(self.surfaceType)
for sfLayer in surfaceLayers:
lId = sfLayer.name()
if lId.contains(surfaceType):
extent = sfLayer.extent()
break
return extent
def clear(self):
self.source.clear()
self.source.setHorizontalHeaderLabels(self.fixedColumnLabels)
# self.setHeaderLabels()
def locate(self, selectedRowIndexes):
if selectedRowIndexes == None or len(selectedRowIndexes) <= 0:
return
sourceRow = self.mapToSource(selectedRowIndexes[0]).row()
objectId = int(self.source.item(sourceRow, self.IndexObjectId).text())
layerId = self.source.item(sourceRow, self.IndexLayerId).text()
QgisHelper.selectFeature(layerId, objectId)
layer = QgsMapLayerRegistry.instance().mapLayer(layerId)
crs = define._canvas.mapSettings().destinationCrs()
if crs.mapUnits() == QGis.Meters:
x = float(self.source.item(sourceRow, self.IndexX).text())
y = float(self.source.item(sourceRow, self.IndexY).text())
extent = QgsRectangle(x - 350, y - 350, x + 350, y + 350)
else:
x, result1 = self.source.item(sourceRow,
self.IndexLon).data().toDouble()
y, result2 = self.source.item(sourceRow,
self.IndexLat).data().toDouble()
extent = QgsRectangle(x - 0.005, y - 0.005, x + 0.005, y + 0.005)
point = QgsPoint(x, y)
# extent = self.getExtentForLocate(sourceRow)
if extent is None:
return
QgisHelper.zoomExtent(point, extent, 2)
pass
def loadObstacles(self, surfaceLayers):
if self.source.rowCount() > 0:
self.source.clear()
self.source.setHorizontalHeaderLabels(self.fixedColumnLabels)
demEvaluateAg = None
existingDemFlag = False
obstacleLayersDEM = QgisHelper.getSurfaceLayers(SurfaceTypes.DEM)
obstacleLayers = QgisHelper.getSurfaceLayers(SurfaceTypes.Obstacles)
if obstacleLayersDEM != None and len(obstacleLayersDEM) > 0:
if QMessageBox.question(
None, "Question",
"Do you want to use DEM for evaluating Obstacle?",
QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes:
self.loadObstaclesDEM(obstacleLayersDEM, surfaceLayers)
if obstacleLayers != None and len(obstacleLayers) > 0:
# if QMessageBox.question(None, "Question", "Do you want to use DEM for evaluating Obstacle?", QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
self.loadObstaclesVector(obstacleLayers, surfaceLayers)
return True
def loadObstaclesDEM(self, obstacleLayersDEM, surfaceLayers):
progressMessageBar = define._messagBar.createMessage(
"Loading DEM Obstacles...")
self.progress = QProgressBar()
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(self.progress)
define._messagBar.pushWidget(progressMessageBar,
define._messagBar.INFO)
maxium = 0
offset = 0.0
self.progress.setValue(0)
wCount = 0
hCount = 0
for ly in obstacleLayersDEM:
demDataProvider = ly.dataProvider()
boundDem = demDataProvider.extent()
xMin = boundDem.xMinimum()
xMax = boundDem.xMaximum()
yMin = boundDem.yMinimum()
yMax = boundDem.yMaximum()
bound = QgisHelper.getIntersectExtent(
ly, QgsGeometry.fromRect(boundDem), surfaceLayers)
# boundGeom = QgsGeometry.fromRect(bound)
if bound == None:
continue
block = ly.dataProvider().block(0, ly.extent(), ly.width(),
ly.height())
xMinimum = ly.dataProvider().extent().xMinimum()
yMaximum = ly.dataProvider().extent().yMaximum()
yMinimum = ly.dataProvider().extent().yMinimum()
xMaximum = ly.dataProvider().extent().xMaximum()
xOffSet = ly.extent().width() / ly.width()
yOffSet = ly.extent().height() / ly.height()
offset = xOffSet
if bound.xMinimum() < xMinimum:
wStartNumber = 0
xStartValue = xMinimum
else:
wStartNumber = int((bound.xMinimum() - xMinimum) / xOffSet)
xStartValue = bound.xMinimum()
if yMaximum < bound.yMaximum():
hStartNumber = 0
yStartValue = yMaximum
else:
hStartNumber = int((yMaximum - bound.yMaximum()) / yOffSet)
yStartValue = bound.yMaximum()
if bound.xMaximum() > xMaximum:
xEndValue = xMaximum
else:
xEndValue = bound.xMaximum()
if yMinimum > bound.yMinimum():
yEndValue = yMinimum
else:
yEndValue = bound.yMinimum()
wCount = int(math.fabs(xEndValue - xStartValue) / xOffSet)
hCount = int(math.fabs(yEndValue - yStartValue) / yOffSet)
pixelCount = hCount
maxium += pixelCount
cellSizeWnd = cellsizeWnd(offset, wCount * hCount, maxium * 0.04)
cellSizeWnd.setWindowTitle("Input Cell Size")
result = cellSizeWnd.exec_()
cellRate = 1
if result == 1:
offset = cellSizeWnd.cellsize
maxium = cellSizeWnd.cellCount + 2
cellRate = cellSizeWnd.cellRate
# print cellSizeWnd.textedit1.text()
if maxium == 0:
return False
self.progress.setMaximum(maxium)
trees = define._treesDEM
tolerance = define._toleranceDEM
for obstacleLayer in obstacleLayersDEM:
obstacleUnits = obstacleLayer.crs().mapUnits()
demDataProvider = obstacleLayer.dataProvider()
boundDem = demDataProvider.extent()
bound = QgisHelper.getIntersectExtent(
obstacleLayer, QgsGeometry.fromRect(boundDem), surfaceLayers)
if bound == None:
continue
boundGeom = QgsGeometry.fromRect(bound)
if not boundGeom.intersects(QgsGeometry.fromRect(boundDem)):
continue
block = obstacleLayer.dataProvider().block(1,
obstacleLayer.extent(),
obstacleLayer.width(),
obstacleLayer.height())
xMinimum = obstacleLayer.extent().xMinimum()
yMaximum = obstacleLayer.extent().yMaximum()
yMinimum = obstacleLayer.extent().yMinimum()
xMaximum = obstacleLayer.extent().xMaximum()
xOffSet = obstacleLayer.extent().width() / obstacleLayer.width()
yOffSet = obstacleLayer.extent().height() / obstacleLayer.height()
if bound.xMinimum() < xMinimum:
hStartNumber = 0
xStartValue = xMinimum
else:
hStartNumber = int((bound.xMinimum() - xMinimum) / xOffSet)
xStartValue = bound.xMinimum()
if yMaximum < bound.yMaximum():
wStartNumber = 0
yStartValue = yMaximum
else:
wStartNumber = int((yMaximum - bound.yMaximum()) / yOffSet)
yStartValue = bound.yMaximum()
if bound.xMaximum() > xMaximum:
xEndValue = xMaximum
else:
xEndValue = bound.xMaximum()
if yMinimum > bound.yMinimum():
yEndValue = yMinimum
else:
yEndValue = bound.yMinimum()
wCount = int(math.fabs(xEndValue - xStartValue) / offset)
hCount = int(math.fabs(yEndValue - yStartValue) / offset)
xPixelWidth = 0.0
yPixelWidth = 0.0
featureID = 0
# i = 0
# k = 0
# altitudeList = []
# self.progress.setValue(0)
# while i <= hCount - 1:
# j = 0
# while j <= wCount - 1:
# if block.isNoData(j * int(cellRate) + wStartNumber, i* int(cellRate) + hStartNumber):
# self.progress.setValue(k)
# QApplication.processEvents()
# j += 1
# k += 1
# altitudeList.append(None)
# continue
# altitude = block.value(j * int(cellRate) + wStartNumber, i * int(cellRate) + hStartNumber)
# altitudeList.append(altitude)
# self.progress.setValue(k)
# QApplication.processEvents()
# j += 1
# k += 1
# i += 1
i = 0
k = 0
name = "DEM"
semiXoffset = xOffSet / 2
semiYoffset = yOffSet / 2
while i <= hCount - 1:
j = 0
while j <= wCount - 1:
if block.isNoData(j * cellRate + wStartNumber,
i * cellRate + hStartNumber):
self.progress.setValue(k)
QApplication.processEvents()
j += 1
k += 1
continue
altitude = block.value(j * cellRate + wStartNumber,
i * cellRate + hStartNumber)
# # if block.isNoData(j * int(cellRate) + wStartNumber, i* int(cellRate) + hStartNumber):
# # j += 1
# # self.progress.setValue(self.progress.value() + 1)
# # QApplication.processEvents()
# # continue
# # altitude = block.value(j* int(cellRate) + wStartNumber, i* int(cellRate)+ hStartNumber)
# altitude = altitudeList[k]
# if altitude == None:
# self.progress.setValue(k)
# QApplication.processEvents()
# j += 1
# k += 1
# continue
point = QgsPoint(
xStartValue + (i * cellRate) * xOffSet + semiXoffset,
yStartValue - (j * cellRate - 1) * yOffSet -
semiYoffset)
position = Point3D()
positionDegree = Point3D()
if define._canvas.mapUnits() == QGis.Meters:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
position = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
position = Point3D(point.x(), point.y(), altitude)
else:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
positionDegree = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
positionDegree = Point3D(point.x(), point.y(),
altitude)
obstacle = Obstacle(name, position, obstacleLayer.id(),
featureID, None, trees,
ObstacleTable.MocMultiplier, tolerance)
obstacle.positionDegree = positionDegree
if self.manualPolygon != None:
if not self.manualPolygon.contains(obstacle.Position):
continue
self.checkObstacle(obstacle)
self.progress.setValue(k)
QApplication.processEvents()
j += 1
featureID += 1
k += 1
i += 1
self.progress.setValue(maxium)
define._messagBar.hide()
self.manualPolygon = None
def loadObstaclesVector(self, obstacleLayers, surfaceLayers):
progressMessageBar = define._messagBar.createMessage(
"Loading Vector Obstacles...")
self.progress = QProgressBar()
self.progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(self.progress)
define._messagBar.pushWidget(progressMessageBar,
define._messagBar.INFO)
maxium = 0
self.progress.setValue(0)
for ly in obstacleLayers:
maxium += ly.featureCount()
if maxium == 0:
return False
self.progress.setMaximum(maxium)
for obstacleLayer in obstacleLayers:
obstacleUnits = obstacleLayer.crs().mapUnits()
features = QgisHelper.getFeaturesInLayerExtent(
define._canvas, obstacleLayer, surfaceLayers,
SelectionModeType.Automatic)
# print len(features)
for feature in features:
name = feature.attribute("Name").toString()
altitude = feature.attribute("Altitude").toFloat()[0]
trees = define._trees
tolerance = define._tolerance
point = feature.geometry().asPoint()
position = Point3D()
positionDegree = Point3D()
if define._canvas.mapUnits() == QGis.Meters:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
position = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
position = Point3D(point.x(), point.y(), altitude)
else:
if define._canvas.mapSettings().destinationCrs(
) != obstacleLayer.crs():
positionDegree = QgisHelper.CrsTransformPoint(
point.x(), point.y(), obstacleLayer.crs(),
define._canvas.mapSettings().destinationCrs(),
altitude)
else:
positionDegree = Point3D(point.x(), point.y(),
altitude)
featureId = feature.id()
layerId = obstacleLayer.id()
obstacle = Obstacle(name, position, layerId, featureId, None,
trees, ObstacleTable.MocMultiplier,
tolerance)
obstacle.positionDegree = positionDegree
# obstacle.positionDegree = positionDegree
self.checkObstacle(obstacle)
self.progress.setValue(self.progress.value() + 1)
QApplication.processEvents()
QApplication.processEvents()
self.progress.setValue(maxium)
define._messagBar.hide()
self.manualPolygon = None
def addObstacleToModel(self, obstacle, checkResult=None):
standardItemList = []
# obstacle.positionDegree = QgisHelper.Meter2Degree(obstacle.Position.x(), obstacle.Position.y())
standardItem = QStandardItem(str(obstacle.featureId))
standardItem.setData(obstacle.featureId)
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.layerId))
standardItem.setData(obstacle.layerId)
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.name))
standardItem.setData(obstacle.name)
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.Position.x()))
standardItem.setData(obstacle.Position.x())
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.Position.y()))
standardItem.setData(obstacle.Position.y())
standardItemList.append(standardItem)
value = QVariant(QgisHelper.strDegree(obstacle.positionDegree.y()))
standardItem = QStandardItem(value.toString())
standardItem.setData(obstacle.positionDegree.y())
standardItemList.append(standardItem)
strV = QgisHelper.strDegree(obstacle.positionDegree.y())
value = QVariant(QgisHelper.strDegree(obstacle.positionDegree.x()))
standardItem = QStandardItem(value.toString())
standardItem.setData(obstacle.positionDegree.x())
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.Position.z()))
standardItem.setData(obstacle.Position.z())
standardItemList.append(standardItem)
standardItem = QStandardItem(
str(Unit.ConvertMeterToFeet(obstacle.Position.z())))
standardItem.setData(Unit.ConvertMeterToFeet(obstacle.Position.z()))
standardItemList.append(standardItem)
standardItem = QStandardItem(str(obstacle.trees))
standardItem.setData(obstacle.trees)
standardItemList.append(standardItem)
standardItem = QStandardItem(
str(Unit.ConvertMeterToFeet(obstacle.trees)))
standardItem.setData(Unit.ConvertMeterToFeet(obstacle.trees))
standardItemList.append(standardItem)
# for i in range(len(standardItemList), self.source.columnCount()):
# standardItemList.append(QStandardItem("None"))
self.source.appendRow(standardItemList)
standardItem = QStandardItem(str(obstacle.mocMultiplier))
standardItem.setData(obstacle.mocMultiplier)
self.source.setItem(self.source.rowCount() - 1,
self.IndexMocMultiplier, standardItem)
def checkObstacle(self, obstacle):
pass
def CompareObstacleRows(self, newRow, row, ignore):
pass
def method_0(self, obstacle_0):
colCount = self.columnCount()
objectId = range(colCount)
objectId[0] = (obstacle_0.featureId)
objectId[1] = (obstacle_0.name)
objectId[2] = (obstacle_0.position.x())
objectId[3] = (obstacle_0.position.y())
objectId[4] = (obstacle_0.Position.z())
position = obstacle_0.position
objectId[6] = (Unit.ConvertMeterToFeet(position.z()))
objectId[7] = (obstacle_0.trees)
objectId[8] = (Unit.ConvertMeterToFeet(obstacle_0.Trees))
if (self.IndexMocMultiplier > -1):
objectId[self.IndexMocMultiplier] = obstacle_0.MocMultiplier
return objectId
def method_1(self, object_0):
pass
class ClusterWidget(QSplitter):
def __init__(self, peaks, parent=None):
QSplitter.__init__(self, Qt.Vertical, parent)
self.peaks = peaks
self.choosenOne = [pe for pe in self.peaks if pe is not None][0]
#self.peakModel = QStandardItemModel()
self.identificationModel = QStandardItemModel()
self.setupUi()
self.setModel()
self.connect(self.calcCorr, SIGNAL('pressed()'), self.setRankValue)
#self.setRankValue()
def setupUi(self):
self.widget = MSView(MSQtCanvas(self.peaks, "peaks@%s"%str(self.peaks[0]),
labels={'bottom':'RT(s)', 'left':'INTENSITY'},
flags='peak'))
self.tableView = QTableView()
self.tableView.horizontalHeader().setStretchLastSection(True)
self.tableView.setSortingEnabled(True)
self.corr = QLabel("Nan")
self.calcCorr = QPushButton("r_coef:")
#v = QVBoxLayout(self)
self.addWidget(self.widget)
self.wid = QWidget()
vb = QVBoxLayout()
vb.addWidget(self.calcCorr)
vb.addWidget(self.corr)
hb = QHBoxLayout(self.wid)
#if self.choosenOne.formulas:
hb.addWidget(self.tableView)
#else:
# hb.addWidget(QLabel("Identification not performed yet..."))
hb.addLayout(vb)
self.addWidget(self.wid)
def setModel(self):
from gui.MetBaseGui import MSStandardItem
#we assume that the different peaks have the same identifiers
#TODO: may have to merge several stuffs later
if self.choosenOne.formulas:
self.identificationModel.setHorizontalHeaderLabels(["score", "formula", "diff mass", "names"])
for i, f in enumerate(self.choosenOne.formulas.iterkeys()):
self.identificationModel.setItem(i, 0, MSStandardItem(str(self.choosenOne.formulas[f]["score"])))
self.identificationModel.setItem(i, 1, QStandardItem(str(f)))
self.identificationModel.setItem(i, 2, MSStandardItem(str(self.choosenOne.formulas[f]["diffmass"])))
self.identificationModel.setItem(i, 3, QStandardItem(self.choosenOne.formulas[f]["names"]))
if self.choosenOne.formulas[f]["names"] != 'Not Found':
for j in xrange(4):
self.identificationModel.item(i, j).setBackground(QBrush(Qt.green))
else:
for j in xrange(4):
self.identificationModel.item(i, j).setBackground(QBrush(Qt.red))
self.tableView.setModel(self.identificationModel)
def setRankValue(self):
#m = qApp.instance().model
#m.pearsonIntraCalculation()
#peaks =[]
#for spl in m:
# peaks+=[p.r_coef for p in spl.mappedPeaks if p.r_coef]
#if not self.choosenOne.r_coef:
self.choosenOne.pCalcBasedOnPeakShape()
#from _bisect import bisect_left
#x = bisect_left(sorted(peaks), self.choosenOne.r_coef)
s = '<br><b>%f</b></br>'%np.round(self.choosenOne.r_coef, 4)
#s+='<br><b>Rank: </b>%d</br>'%abs(len(peaks)-x)
self.corr.setText(s)
class CheckedListBox(QWidget):
def __init__(self, parent):
QWidget.__init__(self, parent)
while not isinstance(parent, QDialog):
parent = parent.parent()
self.setObjectName("CheckedListBox" +
str(len(parent.findChildren(CheckedListBox))))
self.setObjectName("checkBoxWidget")
self.hLayout = QHBoxLayout(self)
self.hLayout.setObjectName("hLayout")
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(sizePolicy)
# self.frame = Frame()
self.listView = QListView(self)
self.hLayout.addWidget(self.listView)
self.stdModel = QStandardItemModel()
self.listView.setModel(self.stdModel)
self.hasObject = False
self.objList = []
self.checkBoxList = []
self.listView.pressed.connect(self.listView_clicked)
def listView_clicked(self, index):
self.emit(SIGNAL("ItemCheck"), self.stdModel.itemFromIndex(index))
def mouseMoveEvent(self, mouseEvent):
pt = mouseEvent.pos()
pass
def Clear(self):
self.stdModel.clear()
self.hasObject = False
self.objList = []
def Add(self, caption, isCheckedFlag=False):
captionStr = ""
if isinstance(caption, str) or isinstance(caption, QString):
captionStr = caption
else:
captionStr = caption.ToString()
self.hasObject = True
self.objList.append([self.stdModel.rowCount(), caption])
item = QStandardItem(captionStr)
item.setCheckable(True)
if isCheckedFlag:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self.stdModel.setItem(self.stdModel.rowCount(), item)
# checkBox = QCheckBox(self)
# checkBox.setText(captionStr)
# checkBox.setChecked(isCheckedFlag)
# checkBox.clicked.connect(self.checkBox_clicked)
# self.hLayout.addWidget(checkBox)
def GetItemChecked(self, index):
if self.stdModel.rowCount() > 0:
item = self.stdModel.item(index)
if item.checkState() == Qt.Unchecked:
return False
return True
return False
def get_CheckedItems(self):
if not self.stdModel.rowCount() > 0:
return []
resultCheckedItems = []
for i in range(self.stdModel.rowCount()):
item = self.stdModel.item(i)
if item.checkState() == Qt.Checked:
flag = False
if self.hasObject:
for obj in self.objList:
if obj[0] == i:
resultCheckedItems.append(obj)
flag = True
break
if not flag:
resultCheckedItems.append(item)
return resultCheckedItems
CheckedItems = property(get_CheckedItems, None, None, None)
def get_Items(self):
if not self.stdModel.rowCount() > 0:
return None
resultItems = []
for i in range(self.stdModel.rowCount()):
item = self.stdModel.item(i)
flag = False
if self.hasObject:
for obj in self.objList:
if obj[0] == i:
resultItems.append(obj)
flag = True
break
if not flag:
resultItems.append(item.text())
return resultItems
Items = property(get_Items, None, None, None)
def get_Enabled(self):
return self.isEnabled()
def set_Enabled(self, bool):
self.setEnabled(bool)
Enabled = property(get_Enabled, set_Enabled, None, None)
def get_Visible(self):
return self.isVisible()
def set_Visible(self, bool):
self.setVisible(bool)
Visible = property(get_Visible, set_Visible, None, None)
class OWConfusionMatrix(widget.OWWidget):
"""Confusion matrix widget"""
name = "Confusion Matrix"
description = "Display a confusion matrix constructed from " \
"the results of classifier evaluations."
icon = "icons/ConfusionMatrix.svg"
priority = 1001
inputs = [("Evaluation Results", Orange.evaluation.Results, "set_results")]
outputs = [("Selected Data", Orange.data.Table)]
quantities = ["Number of instances",
"Proportion of predicted",
"Proportion of actual"]
settingsHandler = settings.ClassValuesContextHandler()
selected_learner = settings.Setting([0], schema_only=True)
selection = settings.ContextSetting(set())
selected_quantity = settings.Setting(0)
append_predictions = settings.Setting(True)
append_probabilities = settings.Setting(False)
autocommit = settings.Setting(True)
UserAdviceMessages = [
widget.Message(
"Clicking on cells or in headers outputs the corresponding "
"data instances",
"click_cell")]
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.vBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.vBox(self.controlArea, "Show")
gui.comboBox(box, self, "selected_quantity", items=self.quantities,
callback=self._update)
box = gui.vBox(self.controlArea, "Select")
gui.button(box, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.vBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit",
"Send Selected", "Send Automatically")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def sizeHint(self):
"""Initial size"""
return QSize(750, 490)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
def _init_table(self, nclasses):
item = self._item(0, 2)
item.setData("Predicted", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData("Actual", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.tableview.setItemDelegateForColumn(0, gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.tableview.setSpan(0, 2, 1, nclasses)
self.tableview.setSpan(2, 0, nclasses, 1)
font = self.tablemodel.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
for p, label in enumerate(self.headers):
for i, j in ((1, p + 2), (p + 2, 1)):
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
item.setFont(bold_font)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
if p < len(self.headers) - 1:
item.setData("br"[j == 1], BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
self._set_item(i, j, item)
hor_header = self.tableview.horizontalHeader()
if len(' '.join(self.headers)) < 120:
hor_header.setResizeMode(QHeaderView.ResizeToContents)
else:
hor_header.setDefaultSectionSize(60)
self.tablemodel.setRowCount(nclasses + 3)
self.tablemodel.setColumnCount(nclasses + 3)
def set_results(self, results):
"""Set the input results."""
prev_sel_learner = self.selected_learner.copy()
self.clear()
self.warning()
self.closeContext()
data = None
if results is not None and results.data is not None:
data = results.data
if data is not None and not data.domain.has_discrete_class:
self.warning("Confusion Matrix cannot show regression results.")
self.results = results
self.data = data
if data is not None:
class_values = data.domain.class_var.values
elif results is not None:
raise NotImplementedError
if results is None:
self.report_button.setDisabled(True)
else:
self.report_button.setDisabled(False)
nmodels = results.predicted.shape[0]
self.headers = class_values + \
[unicodedata.lookup("N-ARY SUMMATION")]
# NOTE: The 'learner_names' is set in 'Test Learners' widget.
if hasattr(results, "learner_names"):
self.learners = results.learner_names
else:
self.learners = ["Learner #{}".format(i + 1)
for i in range(nmodels)]
self._init_table(len(class_values))
self.openContext(data.domain.class_var)
if not prev_sel_learner or prev_sel_learner[0] >= len(self.learners):
self.selected_learner[:] = [0]
else:
self.selected_learner[:] = prev_sel_learner
self._update()
self._set_selection()
self.unconditional_commit()
def clear(self):
"""Reset the widget, clear controls"""
self.results = None
self.data = None
self.tablemodel.clear()
self.headers = []
# Clear learners last. This action will invoke `_learner_changed`
self.learners = []
def select_correct(self):
"""Select the diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
index = self.tablemodel.index(i, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_wrong(self):
"""Select the off-diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
for j in range(i + 1, n):
index = self.tablemodel.index(i, j)
selection.select(index, index)
index = self.tablemodel.index(j, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_none(self):
"""Reset selection"""
self.tableview.selectionModel().clear()
def cell_clicked(self, model_index):
"""Handle cell click event"""
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or i == j == n - 1:
selection = QItemSelection(index(2, 2), index(n - 1, n - 1))
elif i in (1, n - 1):
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j in (1, n - 1):
selection = QItemSelection(index(i, 2), index(i, n - 1))
if selection is not None:
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def commit(self):
"""Output data instances corresponding to selected cells"""
if self.results is not None and self.data is not None \
and self.selected_learner:
indices = self.tableview.selectedIndexes()
indices = {(ind.row() - 2, ind.column() - 2) for ind in indices}
actual = self.results.actual
learner_name = self.learners[self.selected_learner[0]]
predicted = self.results.predicted[self.selected_learner[0]]
selected = [i for i, t in enumerate(zip(actual, predicted))
if t in indices]
row_indices = self.results.row_indices[selected]
extra = []
class_var = self.data.domain.class_var
metas = self.data.domain.metas
if self.append_predictions:
predicted = numpy.array(predicted[selected], dtype=object)
extra.append(predicted.reshape(-1, 1))
var = Orange.data.DiscreteVariable(
"{}({})".format(class_var.name, learner_name),
class_var.values
)
metas = metas + (var,)
if self.append_probabilities and \
self.results.probabilities is not None:
probs = self.results.probabilities[self.selected_learner[0],
selected]
extra.append(numpy.array(probs, dtype=object))
pvars = [Orange.data.ContinuousVariable("p({})".format(value))
for value in class_var.values]
metas = metas + tuple(pvars)
X = self.data.X[row_indices]
Y = self.data.Y[row_indices]
M = self.data.metas[row_indices]
row_ids = self.data.ids[row_indices]
M = numpy.hstack((M,) + tuple(extra))
domain = Orange.data.Domain(
self.data.domain.attributes,
self.data.domain.class_vars,
metas
)
data = Orange.data.Table.from_numpy(domain, X, Y, M)
data.ids = row_ids
data.name = learner_name
else:
data = None
self.send("Selected Data", data)
def _invalidate(self):
indices = self.tableview.selectedIndexes()
self.selection = {(ind.row() - 2, ind.column() - 2) for ind in indices}
self.commit()
def _set_selection(self):
selection = QItemSelection()
index = self.tableview.model().index
for row, col in self.selection:
sel = index(row + 2, col + 2)
selection.select(sel, sel)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def _learner_changed(self):
self._update()
self._set_selection()
self.commit()
def _update(self):
def _isinvalid(x):
return isnan(x) or isinf(x)
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
cmatrix = confusion_matrix(self.results, self.selected_learner[0])
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
n = len(cmatrix)
diag = numpy.diag_indices(n)
colors = cmatrix.astype(numpy.double)
colors[diag] = 0
if self.selected_quantity == 0:
normalized = cmatrix.astype(numpy.int)
formatstr = "{}"
div = numpy.array([colors.max()])
else:
if self.selected_quantity == 1:
normalized = 100 * cmatrix / colsum
div = colors.max(axis=0)
else:
normalized = 100 * cmatrix / rowsum[:, numpy.newaxis]
div = colors.max(axis=1)[:, numpy.newaxis]
formatstr = "{:2.1f} %"
div[div == 0] = 1
colors /= div
colors[diag] = normalized[diag] / normalized[diag].max()
for i in range(n):
for j in range(n):
val = normalized[i, j]
col_val = colors[i, j]
item = self._item(i + 2, j + 2)
item.setData(
"NA" if _isinvalid(val) else formatstr.format(val),
Qt.DisplayRole)
bkcolor = QColor.fromHsl(
[0, 240][i == j], 160,
255 if _isinvalid(col_val) else int(255 - 30 * col_val))
item.setData(QBrush(bkcolor), Qt.BackgroundRole)
item.setData("trbl", BorderRole)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
bold_font = self.tablemodel.invisibleRootItem().font()
bold_font.setBold(True)
def _sum_item(value, border=""):
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setFont(bold_font)
item.setData(border, BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
return item
for i in range(n):
self._set_item(n + 2, i + 2, _sum_item(int(colsum[i]), "t"))
self._set_item(i + 2, n + 2, _sum_item(int(rowsum[i]), "l"))
self._set_item(n + 2, n + 2, _sum_item(int(rowsum.sum())))
def send_report(self):
"""Send report"""
if self.results is not None and self.selected_learner:
self.report_table(
"Confusion matrix for {} (showing {})".
format(self.learners[self.selected_learner[0]],
self.quantities[self.selected_quantity].lower()),
self.tableview)
class GPS(COMCUPluginBase, Ui_GPS):
qtcb_pps = pyqtSignal()
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletGPSV2, *args)
self.setupUi(self)
self.gps = self.device
self.cbe_universal = CallbackEmulator(self.get_universal, self.cb_universal, self.increase_error_count)
self.cbe_universal_gps = CallbackEmulator(
self.get_universal_gps, self.cb_universal_gps, self.increase_error_count
)
self.cbe_universal_glo = CallbackEmulator(
self.get_universal_glo, self.cb_universal_glo, self.increase_error_count
)
self.qtcb_pps.connect(self.cb_pps)
self.gps.register_callback(self.gps.CALLBACK_PULSE_PER_SECOND, self.qtcb_pps.emit)
self.format_combobox.currentIndexChanged.connect(self.format_changed)
self.show_pos.clicked.connect(self.show_pos_clicked)
self.hot_start.clicked.connect(lambda: self.restart_clicked(0))
self.warm_start.clicked.connect(lambda: self.restart_clicked(1))
self.cold_start.clicked.connect(lambda: self.restart_clicked(2))
self.factory_reset.clicked.connect(lambda: self.restart_clicked(3))
self.had_fix = False
self.last_lat = 0
self.last_ns = "U"
self.last_long = 0
self.last_ew = "U"
self.gps_counter = 0
self.glo_counter = 0
self.gps_model = QStandardItemModel(32, 3, self)
self.gps_table.setModel(self.gps_model)
self.gps_model.setHorizontalHeaderItem(0, QStandardItem(u"Elevation (°)"))
self.gps_model.setHorizontalHeaderItem(1, QStandardItem(u"Azimuth (°)"))
self.gps_model.setHorizontalHeaderItem(2, QStandardItem(u"SNR (dB)"))
for i in range(32):
self.gps_model.setVerticalHeaderItem(i, QStandardItem(u"Sat " + str(i + 1)))
self.gps_table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.glo_model = QStandardItemModel(32, 3, self)
self.glo_table.setModel(self.glo_model)
self.glo_model.setHorizontalHeaderItem(0, QStandardItem(u"Elevation (°)"))
self.glo_model.setHorizontalHeaderItem(1, QStandardItem(u"Azimuth (°)"))
self.glo_model.setHorizontalHeaderItem(2, QStandardItem(u"SNR (dB)"))
for i in range(32):
self.glo_model.setVerticalHeaderItem(i, QStandardItem(u"Sat " + str(i + 1 + 64)))
self.glo_table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
def cb_pps(self):
self.fix.setStyleSheet("QLabel { color : green; }")
QTimer.singleShot(200, self.cb_pps_off)
def cb_pps_off(self):
self.fix.setStyleSheet("QLabel { color : black; }")
def get_universal(self):
return (
self.gps.get_coordinates(),
self.gps.get_status(),
self.gps.get_altitude(),
self.gps.get_motion(),
self.gps.get_date_time(),
)
def get_universal_gps(self):
counter = self.gps_counter
self.gps_counter = (self.gps_counter + 1) % 33
if counter == 0:
return counter, self.gps.get_satellite_system_status(self.gps.SATELLITE_SYSTEM_GPS)
else:
return counter, self.gps.get_satellite_status(self.gps.SATELLITE_SYSTEM_GPS, counter)
def get_universal_glo(self):
counter = self.glo_counter
self.glo_counter = (self.glo_counter + 1) % 33
if counter == 0:
return counter, self.gps.get_satellite_system_status(self.gps.SATELLITE_SYSTEM_GLONASS)
else:
return counter, self.gps.get_satellite_status(self.gps.SATELLITE_SYSTEM_GLONASS, counter)
def cb_universal_gps(self, data):
try:
counter, x = data
if counter == 0:
self.update_dop(self.gps_fix, self.gps_dop, self.gps_satallites_used, x)
else:
self.update_table(self.gps_model, counter, x)
except:
pass
def cb_universal_glo(self, data):
try:
counter, x = data
if counter == 0:
self.update_dop(self.glo_fix, self.glo_dop, self.glo_satallites_used, x)
else:
self.update_table(self.glo_model, counter, x)
except:
pass
def update_dop(self, fix, dop, used, data):
if data.fix == 1:
fix.setText("No Fix")
elif data.fix == 2:
fix.setText("2D Fix")
elif data.fix == 3:
fix.setText("3D Fix")
else:
fix.setText("Error")
str_pdop = "%.2f" % (data.pdop / 100.0,)
str_hdop = "%.2f" % (data.hdop / 100.0,)
str_vdop = "%.2f" % (data.vdop / 100.0,)
dop.setText(str(str_pdop) + " / " + str(str_hdop) + " / " + str(str_vdop))
sats = []
for sat in data.satellites:
if sat != 0:
sats.append(sat)
if len(sats) == 0:
used.setText("None")
else:
used.setText(", ".join(map(str, sats)))
def update_table(self, table_model, num, data):
table_model.setItem(num - 1, 0, QStandardItem(str(data.elevation)))
table_model.setItem(num - 1, 1, QStandardItem(str(data.azimuth)))
table_model.setItem(num - 1, 2, QStandardItem(str(data.snr)))
def cb_universal(self, data):
try:
coordinates, status, altitude, motion, date_time = data
self.cb_coordinates(*coordinates)
self.cb_status(*status)
self.cb_altitude(*altitude)
self.cb_motion(*motion)
self.cb_date_time(*date_time)
except:
pass
def show_pos_clicked(self):
if self.had_fix:
google_str = (
self.last_ns
+ self.make_dd_dddddd(self.last_lat, True)
+ "+"
+ self.last_ew
+ self.make_dd_dddddd(self.last_long, True)
)
QDesktopServices.openUrl(QUrl("https://maps.google.com/maps?q=" + google_str))
else:
QDesktopServices.openUrl(QUrl("http://www.google.com/moon/")) # :-)
def format_changed(self, index):
self.cb_coordinates(self.last_lat, self.last_ns, self.last_long, self.last_ew)
def restart_clicked(self, restart_type):
if restart_type > 0:
self.had_fix = False # don't show cached data
self.last_lat = 0
self.last_ns = "U"
self.last_long = 0
self.last_ew = "U"
self.satellites_view.setText("0")
self.latitude.setText("Unknown")
self.ns.setText("U")
self.longitude.setText("Unknown")
self.ew.setText("U")
self.gps_dop.setText("Unknown")
self.glo_dop.setText("Unknown")
self.gps_satallites_used.setText("None")
self.glo_satallites_used.setText("None")
self.gps_fix.setText("No Fix")
self.glo_fix.setText("No Fix")
self.fix.setText("No")
for i in range(32):
self.gps_model.setItem(i, 0, QStandardItem("0"))
self.gps_model.setItem(i, 1, QStandardItem("0"))
self.gps_model.setItem(i, 2, QStandardItem("0"))
self.glo_model.setItem(i, 0, QStandardItem("0"))
self.glo_model.setItem(i, 1, QStandardItem("0"))
self.glo_model.setItem(i, 2, QStandardItem("0"))
self.altitude.setText("Unknown")
self.course.setText("(Unknown)")
self.speed.setText("Unknown")
if restart_type > 1:
self.time.setText("Unknown")
self.gps.restart(restart_type)
def start(self):
self.cbe_universal.set_period(250)
self.cbe_universal_gps.set_period(100)
self.cbe_universal_glo.set_period(100)
def stop(self):
self.cbe_universal.set_period(0)
self.cbe_universal_gps.set_period(0)
self.cbe_universal_glo.set_period(0)
def destroy(self):
pass
def get_url_part(self):
return "gps"
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletGPSV2.DEVICE_IDENTIFIER
def make_ddmm_mmmmm(self, degree):
dd = degree / 1000000
mm = (degree % 1000000) * 60 / 1000000.0
mmmmm = (mm - int(mm)) * 100000
dd_str = str(dd)
mm_str = str(int(mm))
mmmmm_str = str(int(mmmmm + 0.5))
while len(mm_str) < 2:
mm_str = "0" + mm_str
while len(mmmmm_str) < 5:
mmmmm_str = "0" + mmmmm_str
return u"{0}° {1}.{2}’".format(dd_str, mm_str, mmmmm_str)
def make_dd_dddddd(self, degree, url=False):
if url:
return "%2.6f" % (degree / 1000000.0)
else:
return u"%2.6f°" % (degree / 1000000.0)
def make_ddmmss_sss(self, degree):
dd = degree / 1000000
mm = (degree % 1000000) * 60 / 1000000.0
ss = (mm - int(mm)) * 60
sss = (ss - int(ss)) * 1000
dd_str = str(dd)
mm_str = str(int(mm))
ss_str = str(int(ss))
sss_str = str(int(sss + 0.5))
while len(mm_str) < 2:
mm_str = "0" + mm_str
while len(ss_str) < 2:
ss_str = "0" + ss_str
while len(sss_str) < 3:
sss_str = "0" + sss_str
return u"{0}° {1}’ {2}.{3}’’".format(dd_str, mm_str, ss_str, sss_str)
def cb_coordinates(self, lat, ns, long_, ew):
if not self.had_fix:
return
self.last_lat = lat
self.last_ns = ns
self.last_long = long_
self.last_ew = ew
if not ns in ("N", "S"):
self.latitude.setText("Unknown")
self.ns.setText("U")
else:
self.ns.setText(ns)
if self.format_combobox.currentIndex() == 0:
self.latitude.setText(self.make_ddmmss_sss(lat))
elif self.format_combobox.currentIndex() == 1:
self.latitude.setText(self.make_dd_dddddd(lat))
elif self.format_combobox.currentIndex() == 2:
self.latitude.setText(self.make_ddmm_mmmmm(lat))
if not ew in ("E", "W"):
self.longitude.setText("Unknown")
self.ew.setText("U")
else:
self.ew.setText(ew)
if self.format_combobox.currentIndex() == 0:
self.longitude.setText(self.make_ddmmss_sss(long_))
elif self.format_combobox.currentIndex() == 1:
self.longitude.setText(self.make_dd_dddddd(long_))
elif self.format_combobox.currentIndex() == 2:
self.longitude.setText(self.make_ddmm_mmmmm(long_))
def cb_status(self, has_fix, satellites_view):
if has_fix:
self.fix.setText("Yes")
self.had_fix = True
else:
self.fix.setText("No")
self.satellites_view.setText(str(satellites_view))
def cb_altitude(self, altitude, geoidal_separation):
if not self.had_fix:
return
self.altitude.setText("%.2f m (Geoidal Separation: %.2f m)" % (altitude / 100.0, geoidal_separation / 100.0))
def cb_motion(self, course, speed):
if not self.had_fix:
return
self.course.setText(u"(%.2f°)" % (course / 100.0,))
self.speed.setText("%.2f km/h" % (speed / 100.0,))
def cb_date_time(self, date, time):
yy = date % 100
yy += 2000
date /= 100
mm = date % 100
date /= 100
dd = date
time /= 1000
ss = time % 100
time /= 100
mins = time % 100
time /= 100
hh = time
try:
date_str = str(datetime.datetime(yy, mm, dd, hh, mins, ss)) + " UTC"
except:
date_str = "Unknown"
self.time.setText(date_str)
def main(icon_spec):
app = QApplication(sys.argv)
main_window = QMainWindow()
def sigint_handler(*args):
main_window.close()
signal.signal(signal.SIGINT, sigint_handler)
# the timer enables triggering the sigint_handler
signal_timer = QTimer()
signal_timer.start(100)
signal_timer.timeout.connect(lambda: None)
tool_bar = QToolBar()
main_window.addToolBar(Qt.TopToolBarArea, tool_bar)
table_view = QTableView()
table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
table_view.setSelectionMode(QAbstractItemView.SingleSelection)
table_view.setSortingEnabled(True)
main_window.setCentralWidget(table_view)
proxy_model = QSortFilterProxyModel()
proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
proxy_model.setFilterKeyColumn(1)
table_view.setModel(proxy_model)
proxy_model.layoutChanged.connect(table_view.resizeRowsToContents)
item_model = QStandardItemModel()
proxy_model.setSourceModel(item_model)
# get all icons and their available sizes
QIcon.setThemeName("gnome")
icons = []
all_sizes = set([])
for context, icon_names in icon_spec:
for icon_name in icon_names:
icon = QIcon.fromTheme(icon_name)
sizes = []
for size in icon.availableSizes():
size = (size.width(), size.height())
sizes.append(size)
all_sizes.add(size)
sizes.sort()
icons.append({
'context': context,
'icon_name': icon_name,
'icon': icon,
'sizes': sizes,
})
all_sizes = list(all_sizes)
all_sizes.sort()
# input field for filter
def filter_changed(value):
proxy_model.setFilterRegExp(value)
table_view.resizeRowsToContents()
filter_line_edit = QLineEdit()
filter_line_edit.setMaximumWidth(200)
filter_line_edit.setPlaceholderText('Filter name')
filter_line_edit.setToolTip(
'Filter name optionally using regular expressions (' +
QKeySequence(QKeySequence.Find).toString() + ')')
filter_line_edit.textChanged.connect(filter_changed)
tool_bar.addWidget(filter_line_edit)
# actions to toggle visibility of available sizes/columns
def action_toggled(index):
column = 2 + index
table_view.setColumnHidden(column,
not table_view.isColumnHidden(column))
table_view.resizeColumnsToContents()
table_view.resizeRowsToContents()
signal_mapper = QSignalMapper()
for i, size in enumerate(all_sizes):
action = QAction('%dx%d' % size, tool_bar)
action.setCheckable(True)
action.setChecked(True)
tool_bar.addAction(action)
action.toggled.connect(signal_mapper.map)
signal_mapper.setMapping(action, i)
# set tool tip and handle key sequence
tool_tip = 'Toggle visibility of column'
if i < 10:
digit = ('%d' % (i + 1))[-1]
tool_tip += ' (%s)' % QKeySequence('Ctrl+%s' % digit).toString()
action.setToolTip(tool_tip)
signal_mapper.mapped.connect(action_toggled)
# label columns
header_labels = ['context', 'name']
for width, height in all_sizes:
header_labels.append('%dx%d' % (width, height))
item_model.setColumnCount(len(header_labels))
item_model.setHorizontalHeaderLabels(header_labels)
# fill rows
item_model.setRowCount(len(icons))
for row, icon_data in enumerate(icons):
# context
item = QStandardItem(icon_data['context'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 0, item)
# icon name
item = QStandardItem(icon_data['icon_name'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 1, item)
for index_in_all_sizes, size in enumerate(all_sizes):
column = 2 + index_in_all_sizes
if size in icon_data['sizes']:
# icon as pixmap to keep specific size
item = QStandardItem('')
pixmap = icon_data['icon'].pixmap(size[0], size[1])
item.setData(pixmap, Qt.DecorationRole)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
else:
# single space to be sortable against icons
item = QStandardItem(' ')
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
table_view.resizeColumnsToContents()
# manually set row heights because resizeRowsToContents is not working properly
for row, icon_data in enumerate(icons):
if len(icon_data['sizes']) > 0:
max_size = icon_data['sizes'][-1]
table_view.setRowHeight(row, max_size[1])
# enable focus find (ctrl+f) and toggle columns (ctrl+NUM)
def main_window_keyPressEvent(self,
event,
old_keyPressEvent=QMainWindow.keyPressEvent):
if event.matches(QKeySequence.Find):
filter_line_edit.setFocus()
return
if event.modifiers() == Qt.ControlModifier and event.key(
) >= Qt.Key_0 and event.key() <= Qt.Key_9:
index = event.key() - Qt.Key_1
if event.key() == Qt.Key_0:
index += 10
action = signal_mapper.mapping(index)
if action:
action.toggle()
return
old_keyPressEvent(self, event)
main_window.keyPressEvent = new.instancemethod(main_window_keyPressEvent,
table_view, None)
# enable copy (ctrl+c) name of icon to clipboard
def table_view_keyPressEvent(self,
event,
old_keyPressEvent=QTableView.keyPressEvent):
if event.matches(QKeySequence.Copy):
selection_model = self.selectionModel()
if selection_model.hasSelection():
index = selection_model.selectedRows()[0]
source_index = self.model().mapToSource(index)
item = self.model().sourceModel().item(source_index.row(), 1)
icon_name = item.data(Qt.EditRole)
app.clipboard().setText(icon_name.toString())
return
old_keyPressEvent(self, event)
table_view.keyPressEvent = new.instancemethod(table_view_keyPressEvent,
table_view, None)
print 'Icon Theme: ', QIcon.themeName()
print 'Theme Search Paths:'
for item in QIcon.themeSearchPaths():
print item
main_window.showMaximized()
return app.exec_()
class Regression_PLOT_PyQt(QDialog):
"""
This calss return a PyQt GUI with a regression plot
"""
def __init__(self, Minerals=None, string=None, flag=None):
super(Regression_PLOT_PyQt, self).__init__()
if string is not None:
self.stringK, self.stringG, self.stringRho, self.user_input = string
else:
self.stringK = None
self.stringG = None
self.stringRho = None
self.user_input = False
self.resize(1400, 600)
self.Minerals = Minerals
self.dirty = False
#self.user_input = user_input
self.Minerals.original_flag()
self.Minerals.read_data()
self.table = QTableView()
self.model = QStandardItemModel(25, 7, self)
self.model.setHorizontalHeaderLabels([
'flag', 'Water Content', 'Iron Content', 'K (Gpa)', 'G (Gpa)',
'Rho (g/cm³)', 'Reference'
])
for i in range(len(self.Minerals.Flag)):
a = self.Minerals.Return_original_data(i)
for j in range(0, 7):
item = QStandardItem(str(a[j]))
self.model.setItem(i, j, item)
if j != 0:
item.setFlags(Qt.ItemIsEnabled)
item.setBackground(QColor(211, 211, 211))
if flag is not None:
self.Minerals.change_flag(flag)
for i in range(len(self.Minerals.Flag)):
item = QStandardItem(str(self.Minerals.Flag[i]))
self.model.setItem(i, 0, item)
self.table.setModel(self.model)
self.button = QPushButton('Update and use in thermoelastic model')
self.button.clicked.connect(self.Update)
self.button.setAutoDefault(False)
self.button1 = QPushButton('Add data file ')
self.button1.clicked.connect(self.Export)
self.button1.setAutoDefault(False)
self.layout = QGridLayout()
self.label = QLabel()
self.label.setText('''
Please input equation, Water: water content (wt%) and Fe: iron content (mol%)
for example -2.41*Water-30*Fe+81,K'=4.1,
''')
self.Kinput_formula = QLineEdit()
self.Ginput_formula = QLineEdit()
self.Rhoinput_formula = QLineEdit()
if self.stringK is not None:
self.Kinput_formula.setText(self.stringK)
self.Ginput_formula.setText(self.stringG)
self.Rhoinput_formula.setText(self.stringRho)
self.Userinput()
else:
self.Kinput_formula.setText(
self.Minerals.Show_fit_function(self.Minerals.function_K()[0],
self.Minerals.function_K()[1],
"K'",
error=False))
self.Ginput_formula.setText(
self.Minerals.Show_fit_function(self.Minerals.function_G()[0],
self.Minerals.function_G()[1],
"G'",
error=False))
self.Rhoinput_formula.setText(
self.Minerals.Show_fit_function(
self.Minerals.function_Rho()[0],
self.Minerals.function_Rho()[1],
'',
error=False))
self.Kinput_formula.returnPressed.connect(self.Kformula)
self.Ginput_formula.returnPressed.connect(self.Gformula)
self.Rhoinput_formula.returnPressed.connect(self.Rhoformula)
#self.connect(self.Kinput_formula,SIGNAL("returnPressed()"),self.Kformula)
#self.connect(self.Ginput_formula,SIGNAL("returnPressed()"),self.Gformula)
#self.connect(self.Rhoinput_formula,SIGNAL("returnPressed()"),self.Rhoformula)
self.user_change_confrim = QPushButton('Change to user input')
self.user_change_confrim.clicked.connect(self.Userinput)
self.user_change_confrim.setAutoDefault(False)
self.extension = QWidget()
self.extensionLayout = QGridLayout()
self.extensionLayout.setContentsMargins(0, 0, 0, 0)
labelK = QLabel()
labelK.setText('K<sub>0</sub>=')
labelG = QLabel()
labelG.setText('G<sub>0</sub>=')
labelRho = QLabel()
labelRho.setText('Rho<sub>0</sub>=')
self.extensionLayout.addWidget(labelK, 0, 0, 1, 3)
self.extensionLayout.addWidget(labelG, 1, 0, 1, 3)
self.extensionLayout.addWidget(labelRho, 2, 0, 1, 3)
self.extensionLayout.addWidget(self.Kinput_formula, 0, 1, 1, 3)
self.extensionLayout.addWidget(self.Ginput_formula, 1, 1, 1, 3)
self.extensionLayout.addWidget(self.Rhoinput_formula, 2, 1, 1, 3)
self.extensionLayout.addWidget(self.user_change_confrim, 3, 0, 9, 4)
self.extension.setLayout(self.extensionLayout)
self.check_change = QCheckBox("user input")
self.check_change.setChecked(False)
self.check_change.toggled.connect(self.extension.setVisible)
#self.PLOT(switch=True)
self.PLOT()
self.layout.addWidget(self.table, 0, 1, 1, 17)
self.layout.addWidget(self.button, 2, 0, 1, 9)
self.layout.addWidget(self.button1, 2, 9, 1, 9)
self.layout.addWidget(self.check_change, 3, 0, 1, 1)
self.layout.addWidget(self.label, 3, 3, 1, 5)
self.layout.addWidget(self.extension, 4, 0, 1, 9)
self.setLayout(self.layout)
self.extension.hide()
def Kformula(self):
self.stringK = str(self.Kinput_formula.text())
self.K0 = np.array(
re.findall(r"[+-]? *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?",
self.stringK))
return self.K0, self.stringK
def Gformula(self):
self.stringG = str(self.Ginput_formula.text())
self.G0 = np.array(
re.findall(r"[+-]? *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?",
self.stringG))
return self.G0, self.stringG
def Rhoformula(self):
self.stringRho = str(self.Rhoinput_formula.text())
self.Rho0 = np.array(
re.findall(r"[+-]? *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?",
self.stringRho))
return self.Rho0, self.stringRho
def Userinput(self):
self.Minerals.User_Change(self.Kformula(), self.Gformula(),
self.Rhoformula())
self.user_input = True
self.PLOT()
def PLOT(self, switch=True):
if self.dirty == False:
#self.Minerals.Clean_content()
params = []
for i in range(20):
index = self.model.index(i, 0)
try:
aa = (float(self.model.itemData(index)[0]))
#print (aa)
params.append(aa)
except:
break
#print (params)
self.Minerals.Change_data_from_table(params)
#print ('wf')
else:
self.model.setHorizontalHeaderLabels([
'flag', 'Water Content', 'Iron Content', 'K (Gpa)', 'G (Gpa)',
'Rho (g/cm3)', 'Reference'
])
for i in range(len(self.Minerals.Flag)):
#a=self.Minerals.Return_original_data(i)
item = QStandardItem(str(self.Minerals.Flag[i]))
self.model.setItem(i, 0, item)
#==============================================================================
# for j in range(1,7):
# item = QStandardItem(str(a[j]))
# self.model.setItem(i, j,item)
# if j != 0:
# item.setFlags(Qt.ItemIsEnabled)
# item.setBackground(QColor(211,211,211))
#==============================================================================
#print (self.Minerals.Change)
if self.user_input == False:
self.a, self.b, self.c = self.Minerals.PLOT(return_fig=False)
#print (self.Minerals.number_of_data)
self.Kinput_formula.setText(
self.Minerals.Show_fit_function(self.Minerals.function_K()[0],
self.Minerals.function_K()[1],
"K'",
error=False))
self.Ginput_formula.setText(
self.Minerals.Show_fit_function(self.Minerals.function_G()[0],
self.Minerals.function_G()[1],
"G'",
error=False))
self.Rhoinput_formula.setText(
self.Minerals.Show_fit_function(
self.Minerals.function_Rho()[0],
self.Minerals.function_Rho()[1],
'',
error=False))
else:
self.a, self.b, self.c = self.Minerals.PLOT_input_formula(
return_fig=False)
self.canvas1 = FigureCanvas3D(self.a)
self.canvas2 = FigureCanvas3D(self.b)
self.canvas3 = FigureCanvas3D(self.c)
self.canvas1.mpl_connect('pick_event', self.onpick)
self.canvas2.mpl_connect('pick_event', self.onpick)
self.canvas3.mpl_connect('pick_event', self.onpick)
self.toolbar1 = NavigationToolbar(self.canvas1, self)
self.toolbar2 = NavigationToolbar(self.canvas2, self)
self.toolbar3 = NavigationToolbar(self.canvas3, self)
self.layout1_widget = QWidget()
self.layout1 = QGridLayout(self.layout1_widget)
self.layout1_widget.setFixedSize(600, 600)
self.layout1.addWidget(self.canvas1, 0, 1, 5, 5)
self.layout1.addWidget(self.toolbar1, 5, 1, 1, 5)
self.layout1.addWidget(self.canvas2, 6, 1, 5, 5)
self.layout1.addWidget(self.toolbar2, 11, 1, 1, 5)
self.layout1.addWidget(self.canvas3, 12, 1, 5, 5)
self.layout1.addWidget(self.toolbar3, 17, 1, 1, 5)
self.layout.addWidget(self.layout1_widget, 0, 0, 1, 1)
def onpick(self, event):
try:
for i in range(6):
self.model.item(self.ind,
i + 1).setBackground(QColor(211, 211, 211))
except:
pass
count = -1
for j in range(len((self.Minerals.Flag))):
if self.Minerals.Flag[j] == 1:
count += 1
if count == event.ind[0]:
self.ind = j
break
#print (self.ind)
#self.ind = event.ind
for i in range(6):
self.model.item(self.ind,
i + 1).setBackground(QColor(111, 111, 111))
def Update(self):
self.user_input = False
self.dirty = False
self.check_change.setChecked(False)
self.PLOT()
def Export(self):
self.dirty = True
dialog = TextEditor(name=self.Minerals.name)
if dialog.exec_():
pass
self.Minerals.read_data()
self.PLOT()
def ReturnString(self):
aa = self.Minerals.Flag
bb = str(int(aa[0]))
for i in range(1, len(aa)):
bb += str(int(aa[i]))
return [self.stringK, self.stringG, self.stringRho,
self.user_input], bb
parent.appendRow(QStandardItem(str(i+1)))
parent = item"""
"""model = QStandardItemModel(10, 4)
for i in range(10):
for j in range(4):
item = QStandardItem("({0}, {1})".format(i, j))
model.setItem(i, j, item)
if i == 1:
item.appendRow([QStandardItem("..({0}, {1})".format(i*3, k)) for k in range(4)])
"""
model = QStandardItemModel(2,1)
model.setHorizontalHeaderItem(0,QStandardItem("Menu"))
cadastro = QStandardItem("Cadastro")
model.setItem(0,0,cadastro)
pesquisa = QStandardItem("Pesquisa")
model.setItem(1,0,pesquisa)
for i in ["Usuarios", "Empresas"]:
cadastro.appendRow(QStandardItem(i))
pesquisa.appendRow(QStandardItem(i))
parent = QModelIndex()
"""model = QDirModel()
model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
parent = model.index(QDir.currentPath())"""
"""model = QFileSystemModel()"""
class Terminals(QWidget):
ready = pyqtSignal(bool)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = uic.loadUiType('terminal.ui')[0]()
self.ui.setupUi(self)
self.notifier = QSystemTrayIcon(QIcon('arrow-up-icon.png'), self)
self.notifier.show()
self.session = None
self.model = None
self.devices = {}
self.mainloop = None
self.delegate = None
def test_display(self):
if self.mainloop:
self.mainloop.test_display()
def update_device_config(self):
if self.mainloop:
self.mainloop.update_config()
def terminal_open(self, addr):
if self.mainloop:
self.mainloop.terminal_open(addr)
def terminal_close(self, addr):
if self.mainloop:
self.mainloop.terminal_close(addr)
def begin_session(self, fio, access):
if access in ['operator']:
self.ui.cashier.setText(fio)
self.session = (fio, access)
return True
return False
def end_session(self, block=False):
self.ui.cashier.setText(u'')
self.session = None
self.stop_mainloop(block)
return True
def on_mainloop_stopped(self):
self.mainloop = None
if self.session:
self.start_mainloop()
def start_mainloop(self):
if self.mainloop is None:
self.mainloop = Mainloop(devices=self.devices)
self.mainloop.ready.connect(self.on_mainloop_ready)
self.mainloop.stopped.connect(self.on_mainloop_stopped)
self.mainloop.notify.connect(lambda title, msg: self.notifier.showMessage(title, msg))
self.mainloop.start()
def stop_mainloop(self, block=False):
if self.mainloop:
try:
self.mainloop.state.disconnect()
self.mainloop.ready.disconnect()
self.mainloop.notify.disconnect()
except TypeError:
print 'NOTE: mainloop signals disconnect'
if self.model:
[self.ui.terminals.closePersistentEditor(self.model.index(row, 0))
for row in xrange(self.model.rowCount())]
self.mainloop.stop(block)
else:
self.ready.emit(False)
def reset_mainloop(self, devices):
self.devices = devices
if self.mainloop is None:
self.start_mainloop()
else:
self.stop_mainloop()
def on_mainloop_ready(self, ok, titles):
if ok:
self.model = QStandardItemModel(len(titles), 1)
[self.model.setItem(i, QStandardItem(str(addr))) for i, addr in enumerate(titles.keys())]
self.delegate = TerminalDelegate(self.mainloop, titles)
self.mainloop.report.connect(self.delegate.report)
self.mainloop.state.connect(self.delegate.state)
self.ui.terminals.setModel(self.model)
self.ui.terminals.setItemDelegateForColumn(0, self.delegate)
[self.ui.terminals.openPersistentEditor(self.model.index(row, 0))
for row in xrange(self.model.rowCount())]
self.mainloop.db.free_places_update.connect(self.ui.free_places.setValue)
self.mainloop.update_config()
else:
self.model = None
self.mainloop = None
self.ready.emit(ok)
class GPSV2(COMCUPluginBase, Ui_GPSV2):
qtcb_pps = pyqtSignal()
def __init__(self, *args):
COMCUPluginBase.__init__(self, BrickletGPSV2, *args)
self.setupUi(self)
self.gps = self.device
self.cbe_universal = CallbackEmulator(self.get_universal,
self.cb_universal,
self.increase_error_count)
self.cbe_universal_gps = CallbackEmulator(self.get_universal_gps,
self.cb_universal_gps,
self.increase_error_count)
self.cbe_universal_glo = CallbackEmulator(self.get_universal_glo,
self.cb_universal_glo,
self.increase_error_count)
self.qtcb_pps.connect(self.cb_pps)
self.gps.register_callback(self.gps.CALLBACK_PULSE_PER_SECOND,
self.qtcb_pps.emit)
self.format_combobox.currentIndexChanged.connect(self.format_changed)
self.show_pos.clicked.connect(self.show_pos_clicked)
self.hot_start.clicked.connect(lambda: self.restart_clicked(0))
self.warm_start.clicked.connect(lambda: self.restart_clicked(1))
self.cold_start.clicked.connect(lambda: self.restart_clicked(2))
self.factory_reset.clicked.connect(lambda: self.restart_clicked(3))
self.had_fix = False
self.last_lat = 0
self.last_ns = 'U'
self.last_long = 0
self.last_ew = 'U'
self.gps_counter = 0
self.glo_counter = 0
self.gps_model = QStandardItemModel(32, 3, self)
self.gps_table.setModel(self.gps_model)
self.gps_model.setHorizontalHeaderItem(0,
QStandardItem(u'Elevation (°)'))
self.gps_model.setHorizontalHeaderItem(1,
QStandardItem(u'Azimuth (°)'))
self.gps_model.setHorizontalHeaderItem(2, QStandardItem(u'SNR (dB)'))
for i in range(32):
self.gps_model.setVerticalHeaderItem(
i, QStandardItem(u'Sat ' + str(i + 1)))
self.gps_table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.glo_model = QStandardItemModel(32, 3, self)
self.glo_table.setModel(self.glo_model)
self.glo_model.setHorizontalHeaderItem(0,
QStandardItem(u'Elevation (°)'))
self.glo_model.setHorizontalHeaderItem(1,
QStandardItem(u'Azimuth (°)'))
self.glo_model.setHorizontalHeaderItem(2, QStandardItem(u'SNR (dB)'))
for i in range(32):
self.glo_model.setVerticalHeaderItem(
i, QStandardItem(u'Sat ' + str(i + 1 + 64)))
self.glo_table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.fix_led_off_action = QAction('Off', self)
self.fix_led_off_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_OFF))
self.fix_led_on_action = QAction('On', self)
self.fix_led_on_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.FIX_LED_CONFIG_ON
))
self.fix_led_show_heartbeat_action = QAction('Show Heartbeat', self)
self.fix_led_show_heartbeat_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_SHOW_HEARTBEAT))
self.fix_led_show_fix_action = QAction('Show Fix', self)
self.fix_led_show_fix_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_SHOW_FIX))
self.fix_led_show_pps_action = QAction('Show PPS', self)
self.fix_led_show_pps_action.triggered.connect(
lambda: self.gps.set_fix_led_config(BrickletGPSV2.
FIX_LED_CONFIG_SHOW_PPS))
self.extra_configs += [(1, 'Fix LED:', [
self.fix_led_off_action, self.fix_led_on_action,
self.fix_led_show_heartbeat_action, self.fix_led_show_fix_action,
self.fix_led_show_pps_action
])]
def cb_pps(self):
self.fix.setStyleSheet("QLabel { color : green; }")
QTimer.singleShot(200, self.cb_pps_off)
def cb_pps_off(self):
self.fix.setStyleSheet("")
def get_universal(self):
return self.gps.get_coordinates(
), self.gps.get_status(), self.gps.get_altitude(), self.gps.get_motion(
), self.gps.get_date_time()
def get_universal_gps(self):
counter = self.gps_counter
self.gps_counter = (self.gps_counter + 1) % 33
if counter == 0:
return counter, self.gps.get_satellite_system_status(
self.gps.SATELLITE_SYSTEM_GPS)
else:
return counter, self.gps.get_satellite_status(
self.gps.SATELLITE_SYSTEM_GPS, counter)
def get_universal_glo(self):
counter = self.glo_counter
self.glo_counter = (self.glo_counter + 1) % 33
if counter == 0:
return counter, self.gps.get_satellite_system_status(
self.gps.SATELLITE_SYSTEM_GLONASS)
else:
return counter, self.gps.get_satellite_status(
self.gps.SATELLITE_SYSTEM_GLONASS, counter)
def cb_universal_gps(self, data):
try:
counter, x = data
if counter == 0:
self.update_dop(self.gps_fix, self.gps_dop,
self.gps_satallites_used, x)
else:
self.update_table(self.gps_model, counter, x)
except:
pass
def cb_universal_glo(self, data):
try:
counter, x = data
if counter == 0:
self.update_dop(self.glo_fix, self.glo_dop,
self.glo_satallites_used, x)
else:
self.update_table(self.glo_model, counter, x)
except:
pass
def update_dop(self, fix, dop, used, data):
if data.fix == 1:
fix.setText("No Fix")
elif data.fix == 2:
fix.setText("2D Fix")
elif data.fix == 3:
fix.setText("3D Fix")
else:
fix.setText("Unknown")
str_pdop = '%.2f' % (data.pdop / 100.0, )
str_hdop = '%.2f' % (data.hdop / 100.0, )
str_vdop = '%.2f' % (data.vdop / 100.0, )
dop.setText(
str(str_vdop) + ' / ' + str(str_hdop) + ' / ' + str(str_pdop))
if len(data.satellite_numbers) == 0:
used.setText('None')
else:
used.setText(', '.join(map(str, data.satellite_numbers)))
def update_table(self, table_model, num, data):
table_model.setItem(num - 1, 0, QStandardItem(str(data.elevation)))
table_model.setItem(num - 1, 1, QStandardItem(str(data.azimuth)))
table_model.setItem(num - 1, 2, QStandardItem(str(data.snr)))
def cb_universal(self, data):
try:
coordinates, status, altitude, motion, date_time = data
self.cb_coordinates(*coordinates)
self.cb_status(*status)
self.cb_altitude(*altitude)
self.cb_motion(*motion)
self.cb_date_time(*date_time)
except:
pass
def show_pos_clicked(self):
if self.had_fix:
google_str = self.last_ns + self.make_dd_dddddd(
self.last_lat,
True) + '+' + self.last_ew + self.make_dd_dddddd(
self.last_long, True)
QDesktopServices.openUrl(
QUrl('https://maps.google.com/maps?q=' + google_str))
else:
QDesktopServices.openUrl(
QUrl('http://www.google.com/moon/')) # :-)
def format_changed(self, index):
self.cb_coordinates(self.last_lat, self.last_ns, self.last_long,
self.last_ew)
def restart_clicked(self, restart_type):
if restart_type > 0:
self.had_fix = False # don't show cached data
self.last_lat = 0
self.last_ns = 'U'
self.last_long = 0
self.last_ew = 'U'
self.satellites_view.setText('0')
self.latitude.setText("Unknown")
self.ns.setText('U')
self.longitude.setText("Unknown")
self.ew.setText('U')
self.gps_dop.setText("Unknown")
self.glo_dop.setText("Unknown")
self.gps_satallites_used.setText("None")
self.glo_satallites_used.setText("None")
self.gps_fix.setText("No Fix")
self.glo_fix.setText("No Fix")
self.fix.setText("No")
for i in range(32):
self.gps_model.setItem(i, 0, QStandardItem('0'))
self.gps_model.setItem(i, 1, QStandardItem('0'))
self.gps_model.setItem(i, 2, QStandardItem('0'))
self.glo_model.setItem(i, 0, QStandardItem('0'))
self.glo_model.setItem(i, 1, QStandardItem('0'))
self.glo_model.setItem(i, 2, QStandardItem('0'))
self.altitude.setText("Unknown")
self.course.setText("(Unknown)")
self.speed.setText("Unknown")
if restart_type > 1:
self.time.setText("Unknown")
self.gps.restart(restart_type)
def get_fix_led_config_async(self, config):
if config == BrickletGPSV2.FIX_LED_CONFIG_OFF:
self.fix_led_off_action.trigger()
elif config == BrickletGPSV2.FIX_LED_CONFIG_ON:
self.fix_led_on_action.trigger()
elif config == BrickletGPSV2.FIX_LED_CONFIG_SHOW_HEARTBEAT:
self.fix_led_show_heartbeat_action.trigger()
elif config == BrickletGPSV2.FIX_LED_CONFIG_SHOW_FIX:
self.fix_led_show_fix_action.trigger()
elif config == BrickletGPSV2.FIX_LED_CONFIG_SHOW_PPS:
self.fix_led_show_pps_action.trigger()
def start(self):
async_call(self.gps.get_fix_led_config, None,
self.get_fix_led_config_async, self.increase_error_count)
self.cbe_universal.set_period(250)
self.cbe_universal_gps.set_period(100)
self.cbe_universal_glo.set_period(100)
def stop(self):
self.cbe_universal.set_period(0)
self.cbe_universal_gps.set_period(0)
self.cbe_universal_glo.set_period(0)
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickletGPSV2.DEVICE_IDENTIFIER
def make_ddmm_mmmmm(self, degree):
dd = degree / 1000000
mm = (degree % 1000000) * 60 / 1000000.0
mmmmm = (mm - int(mm)) * 100000
dd_str = str(dd)
mm_str = str(int(mm))
mmmmm_str = str(int(mmmmm + 0.5))
while len(mm_str) < 2:
mm_str = '0' + mm_str
while len(mmmmm_str) < 5:
mmmmm_str = '0' + mmmmm_str
return u'{0}° {1}.{2}’'.format(dd_str, mm_str, mmmmm_str)
def make_dd_dddddd(self, degree, url=False):
if url:
return '%2.6f' % (degree / 1000000.0)
else:
return u'%2.6f°' % (degree / 1000000.0)
def make_ddmmss_sss(self, degree):
dd = degree / 1000000
mm = (degree % 1000000) * 60 / 1000000.0
ss = (mm - int(mm)) * 60
sss = (ss - int(ss)) * 1000
dd_str = str(dd)
mm_str = str(int(mm))
ss_str = str(int(ss))
sss_str = str(int(sss + 0.5))
while len(mm_str) < 2:
mm_str = '0' + mm_str
while len(ss_str) < 2:
ss_str = '0' + ss_str
while len(sss_str) < 3:
sss_str = '0' + sss_str
return u'{0}° {1}’ {2}.{3}’’'.format(dd_str, mm_str, ss_str, sss_str)
def cb_coordinates(self, lat, ns, long_, ew):
if not self.had_fix:
return
self.last_lat = lat
self.last_ns = ns
self.last_long = long_
self.last_ew = ew
if not ns in ('N', 'S'):
self.latitude.setText("Unknown")
self.ns.setText('U')
else:
self.ns.setText(ns)
if self.format_combobox.currentIndex() == 0:
self.latitude.setText(self.make_ddmmss_sss(lat))
elif self.format_combobox.currentIndex() == 1:
self.latitude.setText(self.make_dd_dddddd(lat))
elif self.format_combobox.currentIndex() == 2:
self.latitude.setText(self.make_ddmm_mmmmm(lat))
if not ew in ('E', 'W'):
self.longitude.setText("Unknown")
self.ew.setText('U')
else:
self.ew.setText(ew)
if self.format_combobox.currentIndex() == 0:
self.longitude.setText(self.make_ddmmss_sss(long_))
elif self.format_combobox.currentIndex() == 1:
self.longitude.setText(self.make_dd_dddddd(long_))
elif self.format_combobox.currentIndex() == 2:
self.longitude.setText(self.make_ddmm_mmmmm(long_))
def cb_status(self, has_fix, satellites_view):
if has_fix:
self.fix.setText("Yes")
self.had_fix = True
else:
self.fix.setText("No")
self.satellites_view.setText(str(satellites_view))
def cb_altitude(self, altitude, geoidal_separation):
if not self.had_fix:
return
self.altitude.setText('%.2f m (Geoidal Separation: %.2f m)' %
(altitude / 100.0, geoidal_separation / 100.0))
def cb_motion(self, course, speed):
if not self.had_fix:
return
self.course.setText(u'(%.2f°)' % (course / 100.0, ))
self.speed.setText('%.2f km/h' % (speed / 100.0, ))
def cb_date_time(self, date, time):
yy = date % 100
yy += 2000
date /= 100
mm = date % 100
date /= 100
dd = date
time /= 1000
ss = time % 100
time /= 100
mins = time % 100
time /= 100
hh = time
try:
date_str = str(datetime.datetime(yy, mm, dd, hh, mins,
ss)) + " UTC"
except:
date_str = "Unknown"
self.time.setText(date_str)
class Formation(QMainWindow, Ui_Formation):
"""
Class documentation goes here.
"""
#signal
fermeture_reouverture = pyqtSignal()
maj = pyqtSignal()
def __init__(self, engine, gui_parent, parent=None):
"""
Constructor
@param parent reference to the parent widget (QWidget)
"""
super().__init__(parent)
self.setupUi(self)
self.setWindowTitle("Enregistrement d'une formation")
self.engine = engine
self.dateEdit.setDate(pendulum.now('Europe/Paris'))
self.cmr_bdd = Bdd_Cmr(self.engine)
gen_cmr = self.cmr_bdd.recup_cmr_en_activite()
self.remplir_tableau_cmr(next(gen_cmr))
# self.threadpool = QThreadPool()
self.gui_parent = gui_parent
####Threads
self.thread_finish = False
# self.affectation_lancement_threads()
init_domaine = Insertion_Domaine(self.engine)
areas = init_domaine.recuperation_domaine()
# print(areas)
self.model = QStandardItemModel((len(areas) + 1), 1) # 5 rows, 1 col
firstItem = QStandardItem("---- Select domaine(s) ----")
firstItem.setBackground(QBrush(QColor(200, 200, 200)))
firstItem.setSelectable(False)
self.model.setItem(0, 0, firstItem)
for i, area in enumerate(areas):
item = QStandardItem(area)
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setData(Qt.Unchecked, Qt.CheckStateRole)
self.model.setItem(i + 1, 0, item)
self.comboBox_domaine.setModel(self.model)
self.gui_parent.formation_a_modifier.connect(
self.reaffectation_formation)
#
# def affectation_lancement_threads(self):
# """"met en place les threads et les lance"""
# bdd_thread = Gestion_BDD_Thread(self.cmr_bdd )
# bdd_thread.signals.signalData_dispo.connect(self.remplir_tableau_cmr)
# self.threadpool.start(bdd_thread)
### bdd_thread.run()
#
# self.thread_combobox = Gestion_Combobox_domaine_Thread(self.engine)
# self.thread_combobox.signals.signalmodel_dispo.connect(self.affectation_model_combobox_domaine)
## self.thread_combobox.finished.connect(self.danslemille)
# self.threadpool.start(self.thread_combobox)
#
# print(self.thread_combobox)
## self.thread_combobox.run()
#
# @pyqtSlot(QStandardItemModel)
# def affectation_model_combobox_domaine(self, model):
# """permet de recevoir le model créé et affecte au combobox dans le thread specifique"""
# print("jy suis")
# mutex = QMutex()
# mutex.lock()
# self.model = model
# self.comboBox_domaine.setModel(self.model)
#
# self.thread_finish = True
# mutex.unlock()
# print(self.thread_finish)
@pyqtSlot(list)
def remplir_tableau_cmr(self, gen_list_cmr):
self.tableWidget.setRowCount(0)
for cmr in reversed(gen_list_cmr):
# print(cmr)
self.tableWidget.insertRow(0)
item_nom = QTableWidgetItem(cmr.NOM)
item_prenom = QTableWidgetItem(cmr.PRENOM)
self.tableWidget.setItem(0, 0, item_nom)
self.tableWidget.setItem(0, 1, item_prenom)
self.tableWidget.setCellWidget(0, 2, QComboBox())
self.tableWidget.cellWidget(0, 2).addItems(
["*", "Acquise", "À améliorer", "Non acquise"])
self.tableWidget.setCellWidget(0, 3, QComboBox())
self.tableWidget.cellWidget(0, 3).addItems(
[str(x) for x in range(21)])
self.tableWidget.setCellWidget(0, 4, QTextEdit())
self.tableWidget.setCellWidget(0, 5, QCheckBox())
@pyqtSlot()
def on_pushButton_enregistrer_clicked(self):
"""
Slot documentation goes here.
"""
nom_formation = self.lineEdit_nom_formation.text()
if nom_formation:
date = self.dateEdit.date().toString("dd-MM-yyyy")
type_formation = self.comboBox_type_formation.currentText()
# domaine = self.comboBox_domaine.currentText()
domaine = []
for ligne in range(self.model.rowCount()):
if self.model.item(ligne, 0).checkState() == Qt.Checked:
domaine.append(self.model.item(ligne, 0).text())
plan = self.textEdit_plan_formation.toPlainText()
nbr_ligne = self.tableWidget.rowCount()
sauvegarde_dico = []
for ligne in range(nbr_ligne):
if self.tableWidget.cellWidget(ligne, 5).isChecked():
nom = self.tableWidget.item(ligne, 0).text()
prenom = self.tableWidget.item(ligne, 1).text()
gen_id = self.cmr_bdd.recup_id_cmr(nom, prenom)
try:
resultat = self.tableWidget.cellWidget(
ligne, 2).currentText()
except:
resultat = None
try:
note = self.tableWidget.cellWidget(ligne,
3).currentText()
except:
note = None
try:
remarque = self.tableWidget.item(ligne, 4).text()
except:
remarque = None
dico = {
"nom": nom,
"prenom": prenom,
"id": gen_id,
"resultat": resultat,
"note": note,
"remarque": remarque
}
# print(dico)
sauvegarde_dico.append(json.dumps(dico))
sauvegarde = {
"nom_formation": nom_formation,
"date": date,
"type_formation": type_formation,
"domaine": domaine,
"plan": plan,
"participants": sauvegarde_dico
}
# print(sauvegarde)
if self.windowTitle() == "Enregistrement d'une formation":
self.cmr_bdd.insertion_formation(sauvegarde)
self.close()
self.fermeture_reouverture.emit()
else: #on est dans une modification
self.cmr_bdd.modif_formation(self.id_formation_a_modif,
sauvegarde)
self.close()
self.maj.emit()
@pyqtSlot(object)
def reaffectation_formation(self, formation):
"""fct qui reaffecte les donnees recues par le signal"""
self.setWindowTitle("Modification d'une formation")
# print(formation)
self.id_formation_a_modif = formation.ID
# print(formation.ID)
self.lineEdit_nom_formation.setText(formation.NOM_FORMATION)
self.dateEdit.setDate(formation.DATE_FORMATION)
index = self.comboBox_type_formation.findText(formation.TYPE_FORMATION,
Qt.MatchExactly)
if index:
self.comboBox_type_formation.setCurrentIndex(index)
#gestion des domaines :
for domaine in formation.DOMAINE:
for ligne in range(self.model.rowCount()):
# print(f"ligne {ligne}")
if self.model.item(ligne, 0).text() == domaine:
self.model.item(ligne, 0).setData(Qt.Checked,
Qt.CheckStateRole)
self.textEdit_plan_formation.setText(formation.PLAN)
for participant in formation.LIST_PARTICIPANTS:
nom = json.loads(participant)["nom"]
prenom = json.loads(participant)["prenom"]
# id = json.loads(participant)["id"]
resultat = json.loads(participant)["resultat"]
note = json.loads(participant)["note"]
remarque = json.loads(participant)["remarque"]
for ligne in range(self.tableWidget.rowCount()):
if self.tableWidget.item(
ligne, 0).text() == nom and self.tableWidget.item(
ligne, 1).text() == prenom:
index = self.tableWidget.cellWidget(ligne, 2).findText(
resultat, Qt.MatchExactly)
if index != -1:
self.tableWidget.cellWidget(ligne,
2).setCurrentIndex(index)
index = self.tableWidget.cellWidget(ligne, 3).findText(
note, Qt.MatchExactly)
if index != -1:
self.tableWidget.cellWidget(ligne,
3).setCurrentIndex(index)
self.tableWidget.cellWidget(ligne, 4).setText(remarque)
self.tableWidget.cellWidget(ligne, 5).setChecked(True)
def getSampleModel(spl, flags='peak', **kw):
from gui.MetBaseGui import MSStandardItem
if flags not in ('peak', 'cluster', 'id'):
return
model = QStandardItemModel()
if flags == 'peak':
from utils.misc import Hot
areas = [peak.area for peak in spl.rawPeaks.ipeaks()]
mxInt = max(areas)
model.setHorizontalHeaderLabels(MSSample.peakModelLabel)
for i, peak in enumerate(spl.rawPeaks.ipeaks()):
model.setItem(i, 0, MSStandardItem(str(peak.mass())))
model.item(i, 0).setBackground(
QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5)))
model.setItem(i, 1, MSStandardItem(str(peak.rt)))
model.item(i, 1).setBackground(
QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5)))
model.setItem(i, 2, MSStandardItem(str(peak.area)))
model.item(i, 2).setBackground(
QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5)))
model.setItem(i, 3, MSStandardItem(str(peak.sn)))
model.item(i, 3).setBackground(
QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5)))
model.setItem(i, 4, MSStandardItem(str(peak.r_coef)))
model.item(i, 4).setBackground(
QBrush(Hot._get_color(areas[i] / mxInt, True, alpha=0.5)))
elif flags == 'cluster':
model.setHorizontalHeaderLabels(MSSample.clusterModelLabel)
for i, peak in enumerate(spl.mappedPeaks.ipeaks()):
model.setItem(i, 0, MSStandardItem(str(peak.mass())))
model.setItem(i, 1, MSStandardItem(str(peak.rt)))
model.setItem(i, 2, MSStandardItem(str(peak.area)))
info_iso = ""
info_frag = ""
for iso in peak.isoCluster:
info_iso += '%s/%s\t' % (str(iso.mass()), str(iso.rt))
for add in peak.fragCluster:
info_frag += '%s/%s\t' % (str(add.mass()), str(add.rt))
model.setItem(i, 3, MSStandardItem(info_iso))
model.setItem(i, 4, MSStandardItem(info_frag))
return model
class DlgCharting(QDialog):
def __init__(self, parent, data):
QDialog.__init__(self, parent)
self.ui = Ui_ChartingBase()
self.ui.setupUi(self)
self.setWindowTitle("Charting Tool 2")
# self.ui.btnNext.clicked.connect(self.btnNext_clicked)
self.ui.btnPrevious.clicked.connect(self.btnPrevious_clicked)
self.ui.btnExit.clicked.connect(self.btnExit_clicked)
self.ui.txtText1.textChanged.connect(self.txtText1_textChanged)
self.ui.txtText2.textChanged.connect(self.txtText2_textChanged)
self.ui.txtText3.textChanged.connect(self.txtText3_textChanged)
self.ui.txtText4.textChanged.connect(self.txtText4_textChanged)
self.ui.txtText5.textChanged.connect(self.txtText5_textChanged)
self.ui.txtText6.textChanged.connect(self.txtText6_textChanged)
self.ui.txtText7.textChanged.connect(self.txtText7_textChanged)
self.ui.txtText8.textChanged.connect(self.txtText8_textChanged)
self.ui.txtText9.textChanged.connect(self.txtText9_textChanged)
self.ui.txtText10.textChanged.connect(self.txtText10_textChanged)
self.ui.txtText11.textChanged.connect(self.txtText11_textChanged)
self.ui.txtText12.textChanged.connect(self.txtText12_textChanged)
self.ui.txtText13.textChanged.connect(self.txtText13_textChanged)
# self.btnNextAndbtnPreviewSetEnabled()
self.setDataDict = None
self.parentDlg = parent
self.pw = None
self.stdModel = None
self.data = data
self.renderFlag = False
self.changedComposerMap = None
self.tableChangedValue = None
self.straightCount = self.data["StraightCount"]
self.catOfAcftCount = self.data["CatOfAcftCount"][0]
self.rejected.connect(self.dlgRejected)
def dlgRejected(self):
self.parentDlg.show()
def refreshData(self, data):
self.data = data
def txtText1_textChanged(self):
self.txt1.setText(self.ui.txtText1.text())
def txtText2_textChanged(self):
self.txt2.setText(self.ui.txtText2.text())
def txtText3_textChanged(self):
self.txt3.setText(self.ui.txtText3.text())
def txtText4_textChanged(self):
self.txt4.setText(self.ui.txtText4.toPlainText())
def txtText5_textChanged(self):
self.txt5.setText(self.ui.txtText5.toPlainText())
def txtText6_textChanged(self):
self.txt6.setText(self.ui.txtText6.toPlainText())
def txtText7_textChanged(self):
try:
self.txt7.setText(self.ui.txtText7.toPlainText())
except:
pass
def txtText8_textChanged(self):
self.txt8.setText(self.ui.txtText8.text())
def txtText9_textChanged(self):
self.txt9.setText(self.ui.txtText9.text())
def txtText10_textChanged(self):
self.txt10.setText(self.ui.txtText10.text())
def txtText11_textChanged(self):
self.txt11.setText(self.ui.txtText11.text())
def txtText12_textChanged(self):
self.txt12.setText(self.ui.txtText12.text())
def txtText13_textChanged(self):
self.txt13.setText(self.ui.txtText13.text())
# def btnNextAndbtnPreviewSetEnabled(self):
# if self.ui.stackedWidget.currentIndex() == 0:
# self.ui.btnPrevious.setEnabled(False)
# self.ui.frame_2.setVisible(False)
# self.resize(100, 100)
#
# else:
# self.ui.frame_2.setVisible(True)
# self.ui.btnPrevious.setEnabled(True)
# if self.ui.stackedWidget.currentIndex() == self.ui.stackedWidget.count() - 1:
# self.ui.btnNext.setEnabled(False)
# else:
# self.ui.btnNext.setEnabled(True)
def btnExit_clicked(self):
# comp = QgsComposer(self, define._canvas)
# comp.show()
self.setDataDict = dict()
for key, val in self.data.iteritems():
self.setDataDict.__setitem__(key, val)
self.setDataDict.__setitem__("TextData", [
self.ui.txtText1.text(),
self.ui.txtText2.text(),
self.ui.txtText3.text(),
self.ui.txtText4.toPlainText(),
self.ui.txtText5.toPlainText(),
self.ui.txtText6.toPlainText(),
self.ui.txtText7.toPlainText(),
self.ui.txtText8.text(),
self.ui.txtText9.text(),
self.ui.txtText10.text(),
self.ui.txtText11.text(),
self.ui.txtText12.text(),
self.ui.txtText13.text()
])
# self.setDataDict.__setitem__("StraightCount", self.straightCount)
# self.setDataDict.__setitem__("CatOfAcftCount", self.catOfAcftCount)
comp = None
if self.pw == None or not isinstance(self.pw, ComposerDlg):
comp = self.composer(self.setDataDict)
else:
comp = self.composer(self.setDataDict, False)
pwFlag = False
if self.pw == None or not isinstance(self.pw, ComposerDlg):
self.pw = ComposerDlg(self, comp, self.stdModel, self.setDataDict)
pwFlag = True
if not self.renderFlag:
self.pw.show()
if not pwFlag:
self.pw.rePresent(comp, self.stdModel, self.setDataDict)
self.renderFlag = False
def showDlg(self):
self.pw.hide()
self.show()
self.ui.txtText1.setText(self.txt1.text())
self.ui.txtText2.setText(self.txt2.text())
self.ui.txtText3.setText(self.txt3.text())
self.ui.txtText4.setText(self.txt4.text())
self.ui.txtText5.setText(self.txt5.text())
self.ui.txtText6.setText(self.txt6.text())
self.ui.txtText7.setText(self.txt7.text())
self.ui.txtText8.setText(self.txt8.text())
self.ui.txtText9.setText(self.txt9.text())
self.ui.txtText10.setText(self.txt10.text())
self.ui.txtText11.setText(self.txt11.text())
self.ui.txtText12.setText(self.txt12.text())
self.ui.txtText13.setText(self.txt13.text())
# def btnNext_clicked(self):
# if self.ui.stackedWidget.currentIndex() + 1 < self.ui.stackedWidget.count():
# self.ui.stackedWidget.setCurrentIndex(self.ui.stackedWidget.currentIndex() + 1)
# self.btnNextAndbtnPreviewSetEnabled()
def btnPrevious_clicked(self):
self.setVisible(False)
self.parent().show()
# if self.ui.stackedWidget.currentIndex() > 0:
# self.ui.stackedWidget.setCurrentIndex(self.ui.stackedWidget.currentIndex() - 1)
# self.btnNextAndbtnPreviewSetEnabled()
def composer(self, setData, flag=True):
paperWidth = setData["Width"]
paperHeight = setData["Height"]
mapRenderer = define._canvas.mapRenderer()
# comp = None
comp = QgsComposition(mapRenderer)
comp.setPlotStyle(QgsComposition.Print)
comp.setPaperSize(paperWidth, paperHeight)
# rectangleAll = QgsComposerShape(comp)
# rectangleAll.setItemPosition(3, 3, paperWidth - 3, paperHeight - 3)
# rectangleAll.setShapeType(1)
# comp.addItem(rectangleAll)
self.txt1 = QgsComposerLabel(comp)
self.txt1.setItemPosition(20, 20)
self.txt1.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt1.setFont(font)
self.txt1.setText(setData["TextData"][0])
self.txt1.adjustSizeToText()
comp.addItem(self.txt1)
self.txt2 = QgsComposerLabel(comp)
self.txt2.setItemPosition(int(paperWidth / 2) + 10, 20)
self.txt2.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt2.setFont(font)
self.txt2.setText(setData["TextData"][1])
self.txt2.adjustSizeToText()
comp.addItem(self.txt2)
self.txt3 = QgsComposerLabel(comp)
self.txt3.setItemPosition(paperWidth - 40, 20)
self.txt3.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt3.setFont(font)
self.txt3.setText(setData["TextData"][2])
self.txt3.adjustSizeToText()
comp.addItem(self.txt3)
w = int((paperWidth - 40) / 4)
self.txt4 = QgsComposerLabel(comp)
self.txt4.setItemPosition(20, 35)
self.txt4.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt4.setFont(font)
self.txt4.setText(setData["TextData"][3])
self.txt4.adjustSizeToText()
comp.addItem(self.txt4)
self.txt5 = QgsComposerLabel(comp)
self.txt5.setItemPosition(20 + w, 35)
self.txt5.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt5.setFont(font)
self.txt5.setText(setData["TextData"][4])
self.txt5.adjustSizeToText()
comp.addItem(self.txt5)
self.txt6 = QgsComposerLabel(comp)
self.txt6.setItemPosition(20 + w * 2, 35)
self.txt6.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt6.setFont(font)
self.txt6.setText(setData["TextData"][5])
self.txt6.adjustSizeToText()
comp.addItem(self.txt6)
self.txt7 = QgsComposerLabel(comp)
self.txt7.setItemPosition(20 + w * 3, 35)
self.txt7.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt7.setFont(font)
self.txt7.setText(setData["TextData"][6])
self.txt7.adjustSizeToText()
comp.addItem(self.txt7)
# if flag:
x, y = 20, 45
composerMap = QgsComposerMap(comp, x, y, paperWidth - 40, 150)
# composerMap.setPreviewMode(QgsComposerMap.Render)
# composerMap.setGridEnabled(False)
#rect = composerMap.currentMapExtent ()
renderer = composerMap.mapRenderer()
newExtent = renderer.extent()
#Make sure the width/height ratio is the same as in current composer map extent.
#This is to keep the map item frame and the page layout fixed
currentMapExtent = composerMap.currentMapExtent()
currentWidthHeightRatio = currentMapExtent.width(
) / currentMapExtent.height()
newWidthHeightRatio = newExtent.width() / newExtent.height()
if currentWidthHeightRatio < newWidthHeightRatio:
#enlarge height of new extent, ensuring the map center stays the same
newHeight = newExtent.width() / currentWidthHeightRatio
deltaHeight = newHeight - newExtent.height()
newExtent.setYMinimum(newExtent.yMinimum() - deltaHeight / 2)
newExtent.setYMaximum(newExtent.yMaximum() + deltaHeight / 2)
else:
#enlarge width of new extent, ensuring the map center stays the same
newWidth = currentWidthHeightRatio * newExtent.height()
deltaWidth = newWidth - newExtent.width()
newExtent.setXMinimum(newExtent.xMinimum() - deltaWidth / 2)
newExtent.setXMaximum(newExtent.xMaximum() + deltaWidth / 2)
composerMap.beginCommand("Map extent changed")
composerMap.setNewExtent(newExtent)
composerMap.endCommand()
# composerMap.setNewScale(3500)
composerMap.setFrameEnabled(True)
composerMap.setFrameOutlineWidth(1.0)
composerMap.setPreviewMode(QgsComposerMap.Render)
composerMap.updateCachedImage()
composerMap.setGridEnabled(True)
composerMap.setGridPenColor(QColor(255, 255, 255, 0))
composerMap.setGridPenWidth(0.0)
#composerMap.setGridStyle(QgsComposerMap.FrameAnnotationsOnly)
composerMap.setGridIntervalX(1.0)
composerMap.setGridIntervalY(1.0)
# mySymbol1 = composerMap.gridLineSymbol ()
# mySymbol1.setAlpha(0)
#composerMap.setGridLineSymbol(mySymbol1)
composerMap.setShowGridAnnotation(True)
composerMap.setGridAnnotationFormat(1)
composerMap.setGridAnnotationPrecision(0)
composerMap.setGridAnnotationDirection(1, 0)
composerMap.setGridAnnotationDirection(1, 1)
comp.addItem(composerMap)
w = int((paperWidth - 40) / 3)
self.txt8 = QgsComposerLabel(comp)
self.txt8.setItemPosition(20, 225)
self.txt8.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt8.setFont(font)
self.txt8.setText(setData["TextData"][7])
self.txt8.adjustSizeToText()
comp.addItem(self.txt8)
self.txt9 = QgsComposerLabel(comp)
self.txt9.setItemPosition(20 + w, 225)
self.txt9.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt9.setFont(font)
self.txt9.setText(setData["TextData"][8])
self.txt9.adjustSizeToText()
comp.addItem(self.txt9)
self.txt10 = QgsComposerLabel(comp)
self.txt10.setItemPosition(20 + w * 2, 225)
self.txt10.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt10.setFont(font)
self.txt10.setText(setData["TextData"][9])
self.txt10.adjustSizeToText()
comp.addItem(self.txt10)
# profileRect = QgsComposerPicture(comp)
# profileRect.setItemPosition(20, 200, paperWidth - 40, 50)
# comp.addItem(profileRect)
self.txt11 = QgsComposerLabel(comp)
self.txt11.setItemPosition(20, paperHeight - 30)
self.txt11.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt11.setFont(font)
self.txt11.setText(setData["TextData"][10])
self.txt11.adjustSizeToText()
comp.addItem(self.txt11)
self.txt12 = QgsComposerLabel(comp)
self.txt12.setItemPosition(20 + w, paperHeight - 30)
self.txt12.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt12.setFont(font)
self.txt12.setText(setData["TextData"][11])
self.txt12.adjustSizeToText()
comp.addItem(self.txt12)
self.txt13 = QgsComposerLabel(comp)
self.txt13.setItemPosition(20 + w * 2, paperHeight - 30)
self.txt13.setFrameEnabled(False)
font = QFont("Arial", 10)
self.txt13.setFont(font)
self.txt13.setText(setData["TextData"][12])
self.txt13.adjustSizeToText()
comp.addItem(self.txt13)
# gpw = QGraphicsProxyWidget()
self.tblView = QTableView()
tableHeight = None
tableWidth = None
if self.tableChangedValue == None:
self.tblView.setFixedWidth(paperWidth - 40)
tableHeight = 50
tableWidth = paperWidth - 40
self.tblView.setFixedHeight(tableHeight)
else:
self.tblView.setFixedWidth(self.tableChangedValue["Width"])
self.tblView.setFixedHeight(self.tableChangedValue["Height"])
tableHeight = self.tableChangedValue["Height"]
tableWidth = self.tableChangedValue["Width"]
self.tblView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.tblView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
hHeder = self.tblView.horizontalHeader()
hHeder.setVisible(False)
vHeder = self.tblView.verticalHeader()
vHeder.setVisible(False)
# if flag:
self.stdModel = QStandardItemModel()
self.data.__setitem__("TableWidth", tableWidth)
self.data.__setitem__("TableHeight", tableHeight)
self.setTableView(self.tblView, self.stdModel, self.data)
self.calcALT()
self.calcTimeRate()
self.gpw = QGraphicsProxyWidget()
self.gpw.setWidget(self.tblView)
# gpw.setWidget(tblView)
if self.tableChangedValue == None:
self.gpw.setPos(20, 210)
font = QFont()
font.setPixelSize(2)
self.gpw.setFont(font)
else:
self.gpw.setPos(self.tableChangedValue["X"],
self.tableChangedValue["Y"])
font = QFont()
font.setPixelSize(self.tableChangedValue["FontSize"])
self.gpw.setFont(font)
# tblView.setFrameRect(QRect(20, 210, paperWidth - 40, 50))
comp.addItem(self.gpw)
self.connect(self.stdModel, SIGNAL("itemChanged(QStandardItem *)"),
self.stdModel_itemChanged)
return comp
def setTableView(self, tblView, stdModel, data):
for i in range(7):
for j in range(12 + data["CatOfAcftCount"][0]):
item = QStandardItem("")
item.setEditable(True)
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(i, j, item)
item = QStandardItem("O C A ( H )")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(0, 0, item)
item = QStandardItem("C a t of A C F T")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 0, item)
item = QStandardItem("S t r a i g h t-I n A p p r o a c h")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
if data["Template"][0] >= 0 and data["Template"][0] <= 4:
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, 0, item)
item = QStandardItem(
"F i n a l A p p r o a c h L O C D i s t a n c e F A F-M A P t"
)
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(0, data["CatOfAcftCount"][0] + 3, item)
else:
item = QStandardItem("F i n a l A p p r o a c h F A F-M A P t")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(0, data["CatOfAcftCount"][0] + 3, item)
if data["Template"][0] == 5:
item = QStandardItem("LPV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
item = QStandardItem("LNAV / VNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, 0, item)
item = QStandardItem("LNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, 0, item)
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(5, 0, item)
elif data["Template"][0] == 6:
item = QStandardItem("LNAV / VNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
item = QStandardItem("LNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, 0, item)
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, 0, item)
elif data["Template"][0] == 7:
item = QStandardItem("LPV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
item = QStandardItem("LNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, 0, item)
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, 0, item)
elif data["Template"][0] == 8:
item = QStandardItem("LNAV")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, 0, item)
elif data["Template"][0] == 9:
item = QStandardItem("RNP 0.3")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, 0, item)
item = QStandardItem("C i r c l i n g")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, 0, item)
if data["CatOfAcftCount"][0] == 1:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
elif data["CatOfAcftCount"][0] == 2:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
elif data["CatOfAcftCount"][0] == 3:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
item = QStandardItem("C")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 5, item)
elif data["CatOfAcftCount"][0] == 4:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
item = QStandardItem("C")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 5, item)
item = QStandardItem("D")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 6, item)
elif data["CatOfAcftCount"][0] == 5:
if data["CatOfAcftCount"][1] == 4:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
item = QStandardItem("C")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 5, item)
item = QStandardItem("D")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 6, item)
item = QStandardItem("DL")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 7, item)
else:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
item = QStandardItem("C")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 5, item)
item = QStandardItem("D")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 6, item)
item = QStandardItem("E")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 7, item)
elif data["CatOfAcftCount"][0] == 6:
item = QStandardItem("A")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 3, item)
item = QStandardItem("B")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 4, item)
item = QStandardItem("C")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 5, item)
item = QStandardItem("D")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 6, item)
item = QStandardItem("DL")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 7, item)
item = QStandardItem("E")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, 8, item)
# item = QStandardItem("DME MX NM")
# item.setTextAlignment(Qt.AlignCenter)
# stdModel.setItem(1, 6, item)
item = QStandardItem("DME SSA")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 3, item)
item = QStandardItem("6")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 5, item)
item = QStandardItem("5")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 6, item)
item = QStandardItem("4")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 7, item)
item = QStandardItem("3")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 8, item)
item = QStandardItem("2")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 9, item)
item = QStandardItem("1")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(1, data["CatOfAcftCount"][0] + 10, item)
item = QStandardItem("A L T(HGT)")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(2, data["CatOfAcftCount"][0] + 3, item)
item = QStandardItem("G S")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 3, item)
item = QStandardItem("kt")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 5, item)
item = QStandardItem("80")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 6, item)
item = QStandardItem("100")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 7, item)
item = QStandardItem("120")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 8, item)
item = QStandardItem("140")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 9, item)
item = QStandardItem("160")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 10, item)
item = QStandardItem("180")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(3, data["CatOfAcftCount"][0] + 11, item)
item = QStandardItem("T i me")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, data["CatOfAcftCount"][0] + 3, item)
item = QStandardItem("mi n:s")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(4, data["CatOfAcftCount"][0] + 5, item)
item = QStandardItem("Rate Of D e s c e n t")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(5, data["CatOfAcftCount"][0] + 3, item)
item = QStandardItem("ft/mi n")
item.setTextAlignment(Qt.AlignCenter)
stdModel.setItem(5, data["CatOfAcftCount"][0] + 5, item)
tblView.setModel(stdModel)
for i in range(7):
tblView.setRowHeight(i, int(data["TableHeight"] / 7))
for j in range(12 + data["CatOfAcftCount"][0]):
tblView.setColumnWidth(
j,
int(data["TableWidth"] /
float(12 + data["CatOfAcftCount"][0])))
# tblView.setColumnWidth(0, 25)
# tblView.setColumnWidth(6, 20)
tblView.setSpan(0, 0, 1, data["CatOfAcftCount"][0] + 3)
tblView.setSpan(1, 0, 1, 3)
if data["Template"][0] >= 0 and data["Template"][0] <= 4:
tblView.setSpan(2, 0, 1, 3)
tblView.setSpan(2, 3, 1, data["CatOfAcftCount"][0])
tblView.setSpan(3, 0, 1, data["CatOfAcftCount"][0] + 3)
tblView.setSpan(4, 0, 1, 3)
tblView.setSpan(5, 0, 1, 3)
tblView.setSpan(6, 0, 1, 3)
else:
tblView.setSpan(2, 0, 1, 3)
tblView.setSpan(3, 0, 1, 3)
tblView.setSpan(4, 0, 1, 3)
tblView.setSpan(5, 0, 1, 3)
tblView.setSpan(6, 0, 1, 3)
# tblView.setSpan(data["StraightCount"] + 2, 0, 1, 3)
tblView.setSpan(0, data["CatOfAcftCount"][0] + 3, 1, 9)
# tblView.setSpan(1, data["CatOfAcftCount"][0] + 4, 1, 5)
# tblView.setSpan(1, data["CatOfAcftCount"][0] + 9, 1, 3)
# tblView.setSpan(2, data["CatOfAcftCount"][0] + 5, 1, 4)
# tblView.setSpan(2, data["CatOfAcftCount"][0] + 9, 1, 3)
tblView.setSpan(1, data["CatOfAcftCount"][0] + 3, 1, 2)
tblView.setSpan(2, data["CatOfAcftCount"][0] + 3, 1, 2)
tblView.setSpan(3, data["CatOfAcftCount"][0] + 3, 1, 2)
tblView.setSpan(4, data["CatOfAcftCount"][0] + 3, 1, 2)
tblView.setSpan(5, data["CatOfAcftCount"][0] + 3, 1, 2)
tblView.setSpan(6, data["CatOfAcftCount"][0] + 3, 1, 2)
def stdModel_itemChanged(self, item):
if item.row() != 1 and item.row() != 3:
return
self.calcTimeRate()
self.calcALT()
def calcALT(self):
thrAlt = Unit.ConvertFeetToMeter(self.data["ThrAltitude"])
rdhAlt = Unit.ConvertFeetToMeter(self.data["RDHAltitude"])
gradient = self.data["DescentGradient"]
dx = self.data["dX"]
for i in range(7):
item = self.stdModel.item(1,
self.data["CatOfAcftCount"][0] + 5 + i)
val = 0.0
try:
val = float(item.text())
except:
continue
dist = val * 1852
valueHgt = Unit.ConvertFeetToMeter(
(dist - dx) * math.tan(Unit.ConvertDegToRad(gradient)))
valueAlt = valueHgt + thrAlt + rdhAlt
if valueAlt > int(valueAlt):
valueAlt = int(valueAlt) + 1
if valueHgt > int(valueHgt):
valueHgt = int(valueHgt) + 1
itemTemp = QStandardItem(
str(valueAlt) + "\n(" + str(valueHgt) + ")")
itemTemp.setTextAlignment(Qt.AlignCenter)
self.stdModel.setItem(2, self.data["CatOfAcftCount"][0] + 5 + i,
itemTemp)
def calcTimeRate(self):
for i in range(6):
item = self.stdModel.item(3,
self.data["CatOfAcftCount"][0] + 6 + i)
val = 0.0
try:
val = float(item.text())
except:
continue
time = (3600 * self.data["Distance"]) / val
minute = int(time / 60)
second = int(time % 60)
timeStr = str(minute) + " : " + str(second)
if second == 0:
timeStr = str(minute) + " : " + "00"
elif second < 10:
timeStr = str(minute) + " : 0" + str(second)
itemTemp = QStandardItem(timeStr)
itemTemp.setTextAlignment(Qt.AlignCenter)
self.stdModel.setItem(4, self.data["CatOfAcftCount"][0] + 6 + i,
itemTemp)
rate = int(
(val * 6076.1 *
(AngleGradientSlope(self.data["DescentGradient"]).Percent /
float(100))) / float(60))
itemTemp = QStandardItem(str(rate))
itemTemp.setTextAlignment(Qt.AlignCenter)
self.stdModel.setItem(5, self.data["CatOfAcftCount"][0] + 6 + i,
itemTemp)
class SearchDialog(QDialog):
"""
SearchDialog class for the Financeager application.
"""
def __init__(self, parent=None):
"""
Loads the ui layout file.
Populates the model and does some layout adjustments.
:param parent | FinanceagerWindow
"""
super(SearchDialog, self).__init__(parent)
loadUi(__file__, self)
self.__model = QStandardItemModel(self.tableView)
# sorts model according to Item.data, Item.text
self.__model.setSortRole(Qt.UserRole + 1)
self.__model.setHorizontalHeaderLabels(
['Name', 'Value', 'Date', 'Category'])
self.tableView.setModel(self.__model)
self.__sortOrder = 1 #Descending order
self.tableView.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.tableView.adjustSize()
self.setFixedSize(self.size())
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(False)
# CONNECTIONS
self.lineEdit.textEdited.connect(self.displaySearchResult)
self.expendituresButton.clicked.connect(self.displaySearchResult)
self.receiptsButton.clicked.connect(self.displaySearchResult)
self.bothButton.clicked.connect(self.displaySearchResult)
self.tableView.horizontalHeader().sectionClicked.connect(
self.sortByColumn)
self.buttonBox.button(QDialogButtonBox.Ok).clicked.connect(self.close)
def keyPressEvent(self, event):
"""
Reimplementation.
Avoids triggering the OK button when pressing Enter. Considered a
common reaction when searching for stuff.
Unchecks the action_Search of the MainWindow if Esc pressed.
"""
if event.key() == Qt.Key_Enter:
return
elif event.key() == Qt.Key_Escape:
self.parentWidget().action_Search.setChecked(False)
super(SearchDialog, self).keyPressEvent(event)
def closeEvent(self, event):
""" Reimplementation. Unchecks the action_Search of the MainWindow. """
self.parentWidget().action_Search.setChecked(False)
event.accept()
def displaySearchResult(self, pattern=None):
"""
Searches for the pattern given by the user in all months of the current
year. If specified, only the respective expenditures or receipts are
scanned.
If a match is found, new items are cloned and appended to the table.
:param pattern | QString emitted by QLineEdit.textChanged signal
or bool emitted by QRadioButton.clicked signal
or None if called from a BalanceModel (resp.
FinanceagerWindow.updateSearchDialog())
"""
if type(pattern) is bool or pattern is None:
pattern = self.lineEdit.text()
pattern = unicode(pattern)
self.__model.clear()
self.__model.setHorizontalHeaderLabels(
['Name', 'Value', 'Date', 'Category'])
self.setWindowTitle('Search for \'%s\'' % pattern)
if not len(pattern):
self.__model.setItem(0, 0, ResultItem('No pattern specified.'))
return
pattern = pattern.upper()
monthsTabWidget = self.parent().monthsTabWidget
for m in range(12):
if self.expendituresButton.isChecked():
modelList = [monthsTabWidget.widget(m).expendituresModel()]
elif self.receiptsButton.isChecked():
modelList = [monthsTabWidget.widget(m).receiptsModel()]
elif self.bothButton.isChecked():
modelList = [
monthsTabWidget.widget(m).expendituresModel(),
monthsTabWidget.widget(m).receiptsModel()
]
for model in modelList:
for r in range(model.rowCount()):
category = model.item(r)
for e in range(category.rowCount()):
entry = category.child(e)
name = unicode(entry.text())
if name.upper().find(pattern) > -1:
value = category.child(e, 1).value()
date = category.child(e, 2).data()
self.__model.appendRow([
ResultItem(name),
ResultItem(value),
ResultItem(date),
ResultItem(category.text())
])
if not self.__model.hasChildren():
self.__model.setItem(0, 0, ResultItem('No match found.'))
def sortByColumn(self, col):
"""
Called when a section of the horizontalHeader of the model is clicked.
Toggles the sortOrder from descending to ascending and vice versa.
Finally the respective column is sorted.
:param col | int
"""
self.__sortOrder = not self.__sortOrder
self.__model.sort(col, self.__sortOrder)
class DefaultAttributeHandler(QGroupBox, AbstractAttributeHandler):
def __init__(self, attribute, values, parent=None):
QGroupBox.__init__(self, attribute, parent)
self._attribute = attribute
self._current_items = []
self._defaults = {}
self._inputField = None
self._inputFieldType = None
self._insertIndex = -1
self._insertAtEnd = False
self._shortcuts = {}
# Setup GUI
self._layout = FloatingLayout()
self.setLayout(self._layout)
self._buttons = {}
self._labels = {}
#Abhishek : Add Label Dropdown
self.ann_input_combo = ExtendedCombo(self)
self._layout.insertWidget(0,self.ann_input_combo)
self.ann_input_combo.show()
self.modelItem = QStandardItemModel()
self.ann_input_combo.setModel(self.modelItem)
self.ann_input_combo.setModelColumn(0)
self.ann_input_combo.currentIndexChanged.connect(self.onAnnotationValueSelected)
# Add interface elements
self.updateValues(values)
def updateValues(self, values):
if isinstance(values, type):
self.addInputField(values)
else:
for i, val in enumerate(values):
v = val
shortcut = None
widget = None
# Handle the case of the value being a 2-tuple consisting of (value, shortcut)
if type(val) is tuple or type(val) is list:
if len(val) == 2:
v = val[0]
shortcut = val[1]
else:
raise ImproperlyConfigured("Values must be types, strings, numbers, or tuples of length 2: '%s'" % str(val))
# Handle the case where value is a Python type
if isinstance(v, type):
if v is float or v is int or v is str:
self.addInputField(v)
widget = self._inputField
else:
raise ImproperlyConfigured("Input field with type '%s' not supported" % v)
# * marks the position where buttons for new values will be insered
elif val == "*" or val == "<*":
self._insertIndex = self._layout.count()
elif val == "*>":
self._insertIndex = self._layout.count()
self._insertAtEnd = True
# Add the value button
else:
self.addValue(i,v)
# Set default value
if val[0] is not None:
self.ann_input_combo.setCurrentIndex(0)
def defaults(self):
return self._defaults
def autoAddEnabled(self):
return self._insertIndex >= 0
def addValue(self, i ,v, autoAddValue=False):
if v in self._labels: return
if autoAddValue and self._insertIndex < 0: return
self._labels[i] = v
item = QStandardItem(v)
self.modelItem.setItem(i, 0, item)
def reset(self):
self._current_items = []
for v, button in self._buttons.items():
button.setChecked(False)
button.setFlat(True)
def getSelectedValues(self):
return set([str(item[self._attribute]) for item in self._current_items if self._attribute in item and item[self._attribute] is not None])
def updateInputField(self):
if self._inputField is not None:
self._inputField.clear()
selected_values = self.getSelectedValues()
if len(selected_values) > 1:
self._inputField.setPlaceholderText(", ".join(selected_values))
elif len(selected_values) == 1:
it = iter(selected_values)
self._inputField.setText(next(it))
def updateButtons(self):
return
selected_values = self.getSelectedValues()
for val, button in self._buttons.items():
if val in selected_values:
if len(selected_values) > 1:
button.setFlat(False)
button.setChecked(False)
else:
button.setFlat(True)
button.setChecked(True)
else:
button.setFlat(True)
button.setChecked(False)
def setItems(self, items, showItemClasses=False):
self.reset()
if showItemClasses:
title = ", ".join(set([item['class'] for item in items]))
self.setTitle(self._attribute + " (" + title + ")")
else:
self.setTitle(self._attribute)
self._current_items = items
self.updateButtons()
self.updateInputField()
def onAnnotationValueSelected(self, val):
attr = self._attribute
LOG.debug("%s: %s selected" % (attr, val))
selectedVal = str(self.ann_input_combo.currentText())
# Update model item
for item in self._current_items:
item[attr] = selectedVal
# Update input field
self.updateInputField()
def view( self ):
return self.completer.popup()
def index( self ):
return self.currentIndex()
def setTextIfCompleterIsClicked(self, text):
if text:
index = self.findText(text)
self.setCurrentIndex(index)
if __name__ == "__main__":
app = QApplication(sys.argv)
model = QStandardItemModel()
for i,word in enumerate( ['Mario Llosa', 'Marcelo Llosa', 'Paola Perez', 'Paola Llosa', 'Perica Palotes'] ):
item = QStandardItem(word)
model.setItem(i, 0, item)
combo = ExtendedCombo()
combo.setModel(model)
combo.setModelColumn(0)
combo.show()
sys.exit(app.exec_())
class ClusterWidget(QSplitter):
def __init__(self, peaks, parent=None):
QSplitter.__init__(self, Qt.Vertical, parent)
self.peaks = peaks
self.choosenOne = [pe for pe in self.peaks if pe is not None][0]
#self.peakModel = QStandardItemModel()
self.identificationModel = QStandardItemModel()
self.setupUi()
self.setModel()
self.connect(self.calcCorr, SIGNAL('pressed()'), self.setRankValue)
#self.setRankValue()
def setupUi(self):
self.widget = MSView(
MSQtCanvas(self.peaks,
"peaks@%s" % str(self.peaks[0]),
labels={
'bottom': 'RT(s)',
'left': 'INTENSITY'
},
flags='peak'))
self.tableView = QTableView()
self.tableView.horizontalHeader().setStretchLastSection(True)
self.tableView.setSortingEnabled(True)
self.corr = QLabel("Nan")
self.calcCorr = QPushButton("r_coef:")
#v = QVBoxLayout(self)
self.addWidget(self.widget)
self.wid = QWidget()
vb = QVBoxLayout()
vb.addWidget(self.calcCorr)
vb.addWidget(self.corr)
hb = QHBoxLayout(self.wid)
#if self.choosenOne.formulas:
hb.addWidget(self.tableView)
#else:
# hb.addWidget(QLabel("Identification not performed yet..."))
hb.addLayout(vb)
self.addWidget(self.wid)
def setModel(self):
from gui.MetBaseGui import MSStandardItem
#we assume that the different peaks have the same identifiers
#TODO: may have to merge several stuffs later
if self.choosenOne.formulas:
self.identificationModel.setHorizontalHeaderLabels(
["score", "formula", "diff mass", "names"])
for i, f in enumerate(self.choosenOne.formulas.iterkeys()):
self.identificationModel.setItem(
i, 0,
MSStandardItem(str(self.choosenOne.formulas[f]["score"])))
self.identificationModel.setItem(i, 1, QStandardItem(str(f)))
self.identificationModel.setItem(
i, 2,
MSStandardItem(str(
self.choosenOne.formulas[f]["diffmass"])))
self.identificationModel.setItem(
i, 3, QStandardItem(self.choosenOne.formulas[f]["names"]))
if self.choosenOne.formulas[f]["names"] != 'Not Found':
for j in xrange(4):
self.identificationModel.item(i, j).setBackground(
QBrush(Qt.green))
else:
for j in xrange(4):
self.identificationModel.item(i, j).setBackground(
QBrush(Qt.red))
self.tableView.setModel(self.identificationModel)
def setRankValue(self):
#m = qApp.instance().model
#m.pearsonIntraCalculation()
#peaks =[]
#for spl in m:
# peaks+=[p.r_coef for p in spl.mappedPeaks if p.r_coef]
#if not self.choosenOne.r_coef:
self.choosenOne.pCalcBasedOnPeakShape()
#from _bisect import bisect_left
#x = bisect_left(sorted(peaks), self.choosenOne.r_coef)
s = '<br><b>%f</b></br>' % np.round(self.choosenOne.r_coef, 4)
#s+='<br><b>Rank: </b>%d</br>'%abs(len(peaks)-x)
self.corr.setText(s)
self.completer.setCompletionColumn(column)
self.pFilterModel.setFilterKeyColumn(column)
super(ExtendedCombo, self).setModelColumn(column)
def view(self):
return self.completer.popup()
def index(self):
return self.currentIndex()
def set_text_on_completer_clicked(self, text):
if text:
index = self.findText(text)
self.setCurrentIndex(index)
if __name__ == "__main__":
app = QApplication(sys.argv)
model = QStandardItemModel()
for i, word in enumerate(['hola', 'adios', 'hello', 'good bye']):
item = QStandardItem(word)
model.setItem(i, 0, item)
combo = ExtendedCombo()
combo.setModel(model)
combo.setModelColumn(0)
combo.show()
sys.exit(app.exec_())
def getSampleModel(spl, flags='peak', **kw):
from gui.MetBaseGui import MSStandardItem
if flags not in ('peak', 'cluster', 'id'):
return
model = QStandardItemModel()
if flags=='peak':
from utils.misc import Hot
areas=[peak.area for peak in spl.rawPeaks.ipeaks()]
mxInt=max(areas)
model.setHorizontalHeaderLabels(MSSample.peakModelLabel)
for i, peak in enumerate(spl.rawPeaks.ipeaks()):
model.setItem(i, 0, MSStandardItem(str(peak.mass())))
model.item(i, 0).setBackground(QBrush(Hot._get_color(areas[i]/mxInt, True, alpha=0.5)))
model.setItem(i, 1, MSStandardItem(str(peak.rt)))
model.item(i, 1).setBackground(QBrush(Hot._get_color(areas[i]/mxInt, True, alpha=0.5)))
model.setItem(i, 2, MSStandardItem(str(peak.area)))
model.item(i, 2).setBackground(QBrush(Hot._get_color(areas[i]/mxInt, True, alpha=0.5)))
model.setItem(i, 3, MSStandardItem(str(peak.sn)))
model.item(i, 3).setBackground(QBrush(Hot._get_color(areas[i]/mxInt, True, alpha=0.5)))
model.setItem(i, 4, MSStandardItem(str(peak.r_coef)))
model.item(i, 4).setBackground(QBrush(Hot._get_color(areas[i]/mxInt, True, alpha=0.5)))
elif flags=='cluster':
model.setHorizontalHeaderLabels(MSSample.clusterModelLabel)
for i, peak in enumerate(spl.mappedPeaks.ipeaks()):
model.setItem(i, 0, MSStandardItem(str(peak.mass())))
model.setItem(i, 1, MSStandardItem(str(peak.rt)))
model.setItem(i, 2, MSStandardItem(str(peak.area)))
info_iso ="";info_frag=""
for iso in peak.isoCluster:
info_iso += '%s/%s\t'%(str(iso.mass()),str(iso.rt))
for add in peak.fragCluster:
info_frag += '%s/%s\t'%(str(add.mass()),str(add.rt))
model.setItem(i, 3, MSStandardItem(info_iso))
model.setItem(i, 4, MSStandardItem(info_frag))
return model
class Terminals(QWidget):
ready = pyqtSignal(bool)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = uic.loadUiType('terminal.ui')[0]()
self.ui.setupUi(self)
self.notifier = QSystemTrayIcon(QIcon('arrow-up-icon.png'), self)
self.notifier.show()
self.model = None
self.mainloop = None
self.delegate = None
def test_display(self):
if self.mainloop:
self.mainloop.test_display()
def update_device_config(self):
if self.mainloop:
self.mainloop.update_config()
def terminal_open(self, addr):
if self.mainloop:
self.mainloop.terminal_open(addr)
def terminal_close(self, addr):
if self.mainloop:
self.mainloop.terminal_close(addr)
def start_mainloop(self):
if self.mainloop is None:
self.mainloop = Mainloop(parent=self)
self.mainloop.ready.connect(self.on_mainloop_ready)
self.mainloop.notify.connect(lambda title, msg: self.notifier.showMessage(title, msg))
self.mainloop.start()
def stop_mainloop(self):
if self.mainloop:
self.mainloop.state.disconnect()
self.mainloop.ready.disconnect()
self.mainloop.notify.disconnect()
[self.ui.terminals.closePersistentEditor(self.model.index(row, 0))
for row in xrange(self.model.rowCount())]
self.mainloop.stop()
self.mainloop = None
def update_model(self):
self.stop_mainloop()
self.start_mainloop()
def on_mainloop_ready(self, ok, titles):
if ok:
self.model = QStandardItemModel(len(titles), 1)
[self.model.setItem(i, QStandardItem(str(addr))) for i, addr in enumerate(titles.keys())]
self.delegate = TerminalDelegate(self.mainloop, titles)
self.mainloop.report.connect(self.delegate.report)
self.mainloop.state.connect(self.delegate.state)
self.ui.terminals.setModel(self.model)
self.ui.terminals.setItemDelegateForColumn(0, self.delegate)
[self.ui.terminals.openPersistentEditor(self.model.index(row, 0))
for row in xrange(self.model.rowCount())]
self.mainloop.db.free_places_update.connect(self.ui.free_places.setValue)
self.mainloop.update_config()
else:
self.model = None
self.mainloop = None
self.ready.emit(ok)
class OWConfusionMatrix(widget.OWWidget):
name = "Confusion Matrix"
description = "Display confusion matrix constructed from results " \
"of evaluation of classifiers."
icon = "icons/ConfusionMatrix.svg"
priority = 1001
inputs = [("Evaluation Results", Orange.evaluation.Results, "set_results")]
outputs = [("Selected Data", Orange.data.Table)]
quantities = ["Number of instances",
"Proportion of predicted",
"Proportion of actual"]
selected_learner = settings.Setting([])
selected_quantity = settings.Setting(0)
append_predictions = settings.Setting(True)
append_probabilities = settings.Setting(False)
autocommit = settings.Setting(True)
UserAdviceMessages = [
widget.Message(
"Clicking on cells or in headers outputs the corresponding "
"data instances",
"click_cell")]
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.widgetBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.widgetBox(self.controlArea, "Show")
gui.comboBox(box, self, "selected_quantity", items=self.quantities,
callback=self._update)
box = gui.widgetBox(self.controlArea, "Select")
gui.button(box, self, "Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "None",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit",
"Send Data", "Auto send is on")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def sizeHint(self):
return QSize(750, 490)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
def set_results(self, results):
"""Set the input results."""
self.clear()
self.warning([0, 1])
data = None
if results is not None:
if results.data is not None:
data = results.data
if data is not None and not data.domain.has_discrete_class:
data = None
results = None
self.warning(
0, "Confusion Matrix cannot be used for regression results.")
self.results = results
self.data = data
if data is not None:
class_values = data.domain.class_var.values
elif results is not None:
raise NotImplementedError
if results is not None:
nmodels, ntests = results.predicted.shape
self.headers = class_values + \
[unicodedata.lookup("N-ARY SUMMATION")]
# NOTE: The 'learner_names' is set in 'Test Learners' widget.
if hasattr(results, "learner_names"):
self.learners = results.learner_names
else:
self.learners = ["Learner #%i" % (i + 1)
for i in range(nmodels)]
item = self._item(0, 2)
item.setData("Predicted", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData("Actual", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.tableview.setItemDelegateForColumn(
0, gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.tableview.setSpan(0, 2, 1, len(class_values))
self.tableview.setSpan(2, 0, len(class_values), 1)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
for p, label in enumerate(self.headers):
for i, j in ((1, p + 2), (p + 2, 1)):
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
item.setData(QBrush(QColor(208, 208, 208)),
Qt.BackgroundColorRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
self._set_item(i, j, item)
hor_header = self.tableview.horizontalHeader()
if len(' '.join(self.headers)) < 120:
hor_header.setResizeMode(QHeaderView.ResizeToContents)
else:
hor_header.setDefaultSectionSize(60)
self.tablemodel.setRowCount(len(class_values) + 3)
self.tablemodel.setColumnCount(len(class_values) + 3)
self.selected_learner = [0]
self._update()
def clear(self):
self.results = None
self.data = None
self.tablemodel.clear()
self.headers = []
# Clear learners last. This action will invoke `_learner_changed`
# method
self.learners = []
def select_correct(self):
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
index = self.tablemodel.index(i, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect
)
def select_wrong(self):
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
for j in range(i + 1, n):
index = self.tablemodel.index(i, j)
selection.select(index, index)
index = self.tablemodel.index(j, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect
)
def select_none(self):
self.tableview.selectionModel().clear()
def cell_clicked(self, model_index):
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or i == j == n - 1:
selection = QItemSelection(index(2, 2), index(n - 1, n - 1))
elif i in (1, n - 1):
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j in (1, n - 1):
selection = QItemSelection(index(i, 2), index(i, n - 1))
if selection is not None:
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect
)
def commit(self):
if self.results is not None and self.data is not None \
and self.selected_learner:
indices = self.tableview.selectedIndexes()
indices = {(ind.row() - 2, ind.column() - 2) for ind in indices}
actual = self.results.actual
selected_learner = self.selected_learner[0]
learner_name = self.learners[selected_learner]
predicted = self.results.predicted[selected_learner]
selected = [i for i, t in enumerate(zip(actual, predicted))
if t in indices]
row_indices = self.results.row_indices[selected]
extra = []
class_var = self.data.domain.class_var
metas = self.data.domain.metas
if self.append_predictions:
predicted = numpy.array(predicted[selected], dtype=object)
extra.append(predicted.reshape(-1, 1))
var = Orange.data.DiscreteVariable(
"{}({})".format(class_var.name, learner_name),
class_var.values
)
metas = metas + (var,)
if self.append_probabilities and \
self.results.probabilities is not None:
probs = self.results.probabilities[selected_learner, selected]
extra.append(numpy.array(probs, dtype=object))
pvars = [Orange.data.ContinuousVariable("p({})".format(value))
for value in class_var.values]
metas = metas + tuple(pvars)
X = self.data.X[row_indices]
Y = self.data.Y[row_indices]
M = self.data.metas[row_indices]
row_ids = self.data.ids[row_indices]
M = numpy.hstack((M,) + tuple(extra))
domain = Orange.data.Domain(
self.data.domain.attributes,
self.data.domain.class_vars,
metas
)
data = Orange.data.Table.from_numpy(domain, X, Y, M)
data.ids = row_ids
data.name = learner_name
else:
data = None
self.send("Selected Data", data)
def _invalidate(self):
self.commit()
def _learner_changed(self):
# The selected learner has changed
indices = self.tableview.selectedIndexes()
self._update()
selection = QItemSelection()
for sel in indices:
selection.select(sel, sel)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect
)
self.commit()
def _update(self):
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
index = self.selected_learner[0]
cmatrix = confusion_matrix(self.results, index)
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
total = rowsum.sum()
if self.selected_quantity == 0:
value = lambda i, j: int(cmatrix[i, j])
elif self.selected_quantity == 1:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / colsum[i])
if colsum[i] else "N/A")
elif self.selected_quantity == 2:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / rowsum[i])
if colsum[i] else "N/A")
else:
assert False
for i, row in enumerate(cmatrix):
for j, _ in enumerate(row):
item = self._item(i + 2, j + 2)
item.setData(value(i, j), Qt.DisplayRole)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
model = self.tablemodel
font = model.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
def sum_item(value):
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setFont(bold_font)
return item
N = len(colsum)
for i in range(N):
model.setItem(N + 2, i + 2, sum_item(int(colsum[i])))
model.setItem(i + 2, N + 2, sum_item(int(rowsum[i])))
model.setItem(N + 2, N + 2, sum_item(int(total)))
def main(icon_spec):
app = QApplication(sys.argv)
main_window = QMainWindow()
def sigint_handler(*args):
main_window.close()
signal.signal(signal.SIGINT, sigint_handler)
# the timer enables triggering the sigint_handler
signal_timer = QTimer()
signal_timer.start(100)
signal_timer.timeout.connect(lambda: None)
tool_bar = QToolBar()
main_window.addToolBar(Qt.TopToolBarArea, tool_bar)
table_view = QTableView()
table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
table_view.setSelectionMode(QAbstractItemView.SingleSelection)
table_view.setSortingEnabled(True)
main_window.setCentralWidget(table_view)
proxy_model = QSortFilterProxyModel()
proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
proxy_model.setFilterKeyColumn(1)
table_view.setModel(proxy_model)
proxy_model.layoutChanged.connect(table_view.resizeRowsToContents)
item_model = QStandardItemModel()
proxy_model.setSourceModel(item_model)
# get all icons and their available sizes
QIcon.setThemeName("gnome")
icons = []
all_sizes = set([])
for context, icon_names in icon_spec:
for icon_name in icon_names:
icon = QIcon.fromTheme(icon_name)
sizes = []
for size in icon.availableSizes():
size = (size.width(), size.height())
sizes.append(size)
all_sizes.add(size)
sizes.sort()
icons.append({
'context': context,
'icon_name': icon_name,
'icon': icon,
'sizes': sizes,
})
all_sizes = list(all_sizes)
all_sizes.sort()
# input field for filter
def filter_changed(value):
proxy_model.setFilterRegExp(value)
table_view.resizeRowsToContents()
filter_line_edit = QLineEdit()
filter_line_edit.setMaximumWidth(200)
filter_line_edit.setPlaceholderText('Filter name')
filter_line_edit.setToolTip('Filter name optionally using regular expressions (' + QKeySequence(QKeySequence.Find).toString() + ')')
filter_line_edit.textChanged.connect(filter_changed)
tool_bar.addWidget(filter_line_edit)
# actions to toggle visibility of available sizes/columns
def action_toggled(index):
column = 2 + index
table_view.setColumnHidden(column, not table_view.isColumnHidden(column))
table_view.resizeColumnsToContents()
table_view.resizeRowsToContents()
signal_mapper = QSignalMapper()
for i, size in enumerate(all_sizes):
action = QAction('%dx%d' % size, tool_bar)
action.setCheckable(True)
action.setChecked(True)
tool_bar.addAction(action)
action.toggled.connect(signal_mapper.map)
signal_mapper.setMapping(action, i)
# set tool tip and handle key sequence
tool_tip = 'Toggle visibility of column'
if i < 10:
digit = ('%d' % (i + 1))[-1]
tool_tip += ' (%s)' % QKeySequence('Ctrl+%s' % digit).toString()
action.setToolTip(tool_tip)
signal_mapper.mapped.connect(action_toggled)
# label columns
header_labels = ['context', 'name']
for width, height in all_sizes:
header_labels.append('%dx%d' % (width, height))
item_model.setColumnCount(len(header_labels))
item_model.setHorizontalHeaderLabels(header_labels)
# fill rows
item_model.setRowCount(len(icons))
for row, icon_data in enumerate(icons):
# context
item = QStandardItem(icon_data['context'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 0, item)
# icon name
item = QStandardItem(icon_data['icon_name'])
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, 1, item)
for index_in_all_sizes, size in enumerate(all_sizes):
column = 2 + index_in_all_sizes
if size in icon_data['sizes']:
# icon as pixmap to keep specific size
item = QStandardItem('')
pixmap = icon_data['icon'].pixmap(size[0], size[1])
item.setData(pixmap, Qt.DecorationRole)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
else:
# single space to be sortable against icons
item = QStandardItem(' ')
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item_model.setItem(row, column, item)
table_view.resizeColumnsToContents()
# manually set row heights because resizeRowsToContents is not working properly
for row, icon_data in enumerate(icons):
if len(icon_data['sizes']) > 0:
max_size = icon_data['sizes'][-1]
table_view.setRowHeight(row, max_size[1])
# enable focus find (ctrl+f) and toggle columns (ctrl+NUM)
def main_window_keyPressEvent(self, event, old_keyPressEvent=QMainWindow.keyPressEvent):
if event.matches(QKeySequence.Find):
filter_line_edit.setFocus()
return
if event.modifiers() == Qt.ControlModifier and event.key() >= Qt.Key_0 and event.key() <= Qt.Key_9:
index = event.key() - Qt.Key_1
if event.key() == Qt.Key_0:
index += 10
action = signal_mapper.mapping(index)
if action:
action.toggle()
return
old_keyPressEvent(self, event)
main_window.keyPressEvent = new.instancemethod(main_window_keyPressEvent, table_view, None)
# enable copy (ctrl+c) name of icon to clipboard
def table_view_keyPressEvent(self, event, old_keyPressEvent=QTableView.keyPressEvent):
if event.matches(QKeySequence.Copy):
selection_model = self.selectionModel()
if selection_model.hasSelection():
index = selection_model.selectedRows()[0]
source_index = self.model().mapToSource(index)
item = self.model().sourceModel().item(source_index.row(), 1)
icon_name = item.data(Qt.EditRole)
app.clipboard().setText(icon_name.toString())
return
old_keyPressEvent(self, event)
table_view.keyPressEvent = new.instancemethod(table_view_keyPressEvent, table_view, None)
print 'Icon Theme: ', QIcon.themeName()
print 'Theme Search Paths:'
for item in QIcon.themeSearchPaths():
print item
main_window.showMaximized()
return app.exec_()
class InputDialog(GenericDialog):
TBL_HEADER_LABEL=["Input Mesh", "Output group name"]
def __init__(self, parent=None, name="InputDialog", modal=0):
"""
This initializes a dialog windows to define the input data of
the plugin function. The input data consist in a list of
meshes characterizes each by a name, a pointer to the smesh
servant object, a type and a group name (see data model in the
inputdata.py).
"""
GenericDialog.__init__(self, parent, name, modal)
# Set up the user interface from Designer.
self.__ui = Ui_InputFrame()
# BE CAREFULL HERE, the ui form is NOT drawn in the global
# dialog (already containing some generic widgets) but in the
# center panel created in the GenericDialog as a void
# container for the form. The InputFrame form is supposed
# here to create only the widgets to be placed in the center
# panel. Then, the setupUi function of this form draws itself
# in the specified panel, i.e. the panel returned by
# self.getPanel().
self.__ui.setupUi(self.getPanel())
self.setWindowTitle("Specification of input files")
# The icon are supposed to be located in the plugin folder,
# i.e. in the same folder than this python module file
iconfolder=os.path.dirname(os.path.abspath(__file__))
icon = QIcon()
icon.addFile(os.path.join(iconfolder,"select.png"))
self.__ui.btnSmeshObject.setIcon(icon)
icon = QIcon()
icon.addFile(os.path.join(iconfolder,"addinput.png"))
self.__ui.btnAddInput.setIcon(icon)
icon = QIcon()
icon.addFile(os.path.join(iconfolder,"deleteinput.png"))
self.__ui.btnDeleteInput.setIcon(icon)
# We specify here the items in the combo box (even if already
# defined in the designer) so that we can be sure of the item
# indexation.
self.MESHTYPE_ICONS = {}
meshTypeIndex = InputData.MESHTYPES.CONCRETE
self.__ui.cmbMeshType.setItemText(meshTypeIndex, "Béton")
icon = QIcon()
icon.addFile(os.path.join(iconfolder,"concrete.png"))
self.__ui.cmbMeshType.setItemIcon(meshTypeIndex, icon)
self.MESHTYPE_ICONS[meshTypeIndex] = icon
meshTypeIndex = InputData.MESHTYPES.STEELBAR
self.__ui.cmbMeshType.setItemText(meshTypeIndex, "Acier")
icon = QIcon()
icon.addFile(os.path.join(iconfolder,"steelbar.png"))
self.__ui.cmbMeshType.setItemIcon(meshTypeIndex, icon)
self.MESHTYPE_ICONS[meshTypeIndex] = icon
# The click on btnSmeshObject (signal clicked() emitted by the
# button btnSmeshObject) is connected to the slot
# onSelectSmeshObject, etc ...
self.connect(self.__ui.btnSmeshObject, SIGNAL('clicked()'), self.onSelectSmeshObject )
self.connect(self.__ui.btnAddInput, SIGNAL('clicked()'), self.onAddInput )
self.connect(self.__ui.btnDeleteInput, SIGNAL('clicked()'), self.onDeleteInput )
# Set up the model of the Qt table list
self.__inputModel = QStandardItemModel(0,2)
self.__inputModel.setHorizontalHeaderLabels(InputDialog.TBL_HEADER_LABEL)
self.__ui.tblListInput.setModel(self.__inputModel)
self.__ui.tblListInput.verticalHeader().hide()
self.__ui.tblListInput.horizontalHeader().setStretchLastSection(True)
# Note that the type is not display explicitly in the Qt table
# because it is specified using an icon on the text of the
# name item.
# Note that PADDER does not support group name longer than 8
# characters. We apply then this limit in the gui field.
self.__ui.txtGroupName.setMaxLength(GROUPNAME_MAXLENGTH)
self.clear()
self.smeshStudyTool = SMeshStudyTools()
def clear(self):
"""
This function clears the data gui area and associated values.
"""
self.__ui.txtSmeshObject.setText("")
self.__ui.txtGroupName.setText("")
self.__inputModel.clear()
self.__inputModel.setHorizontalHeaderLabels(InputDialog.TBL_HEADER_LABEL)
if not DEBUG_MODE:
self.__ui.txtSmeshObject.setEnabled(False)
self.__ui.btnAddInput.setEnabled(False)
self.__selectedMesh = None
self.__dictInputData = {}
self.__nbConcreteMesh = 0
self.__nbSteelbarMesh = 0
def accept(self):
"""
This function is the slot connected to the button OK
"""
# The dialog is raised in a non modal mode to get
# interactivity with the parents windows. Then we have to emit
# a signal to warn the parent observer that the dialog has
# been validated so that it can process the event
GenericDialog.accept(self)
if self.wasOk():
self.emit(SIGNAL('inputValidated()'))
def onSelectSmeshObject(self):
'''
This function is the slot connected on the mesh selection
button. It memorizes the selected mesh and put its name in the
text field of the dialog box.
'''
mySObject, myEntry = guihelper.getSObjectSelected()
if CORBA.is_nil(mySObject):
self.__ui.txtSmeshObject.setText("You must choose a mesh")
self.__ui.txtGroupName.setText("")
self.__ui.txtSmeshObject.setEnabled(False)
self.__ui.btnAddInput.setEnabled(False)
self.__selectedMesh = None
return
self.smeshStudyTool.updateStudy(studyedit.getActiveStudyId())
self.__selectedMesh = self.smeshStudyTool.getMeshObjectFromSObject(mySObject)
if CORBA.is_nil(self.__selectedMesh):
self.__ui.txtSmeshObject.setText("The selected object is not a mesh")
self.__ui.txtGroupName.setText("")
self.__ui.txtSmeshObject.setEnabled(False)
self.__ui.btnAddInput.setEnabled(False)
self.__selectedMesh = None
return
myName = mySObject.GetName()
self.__ui.txtSmeshObject.setText(myName)
self.__ui.txtSmeshObject.setEnabled(True)
self.__ui.btnAddInput.setEnabled(True)
# We can suggest a default group name from the mesh name
self.__ui.txtGroupName.setText(myName)
def onAddInput(self):
"""
This function is the slot connected to the Add button. It
creates a new entry in the list of input data, or updates this
entry if it already exists.
"""
meshName = str(self.__ui.txtSmeshObject.text().trimmed())
meshObject = self.__selectedMesh
meshType = self.__ui.cmbMeshType.currentIndex()
groupName = str(self.__ui.txtGroupName.text().trimmed())
self.__addInputInGui(meshName, meshObject, meshType, groupName)
self.__addInputInMap(meshName, meshObject, meshType, groupName)
def __addInputInGui(self, meshName, meshObject, meshType, groupName):
"""
This function adds an entry with the specified data int the
GUI table (for data visualization purpose).
"""
# The mesh name is used as the key index in the model. We have
# to check first if this item already exists in the list.
tblItems = self.__inputModel.findItems(meshName)
row = self.__inputModel.rowCount()
if not tblItems:
tblItems = []
tblItems.append(QStandardItem()) # input mesh name
tblItems.append(QStandardItem()) # output group name
else:
row = tblItems[0].index().row()
tblItems.append(self.__inputModel.item(row,1))
tblItems[0].setText(meshName)
tblItems[0].setIcon(self.MESHTYPE_ICONS[meshType])
tblItems[1].setText(groupName)
self.__inputModel.setItem(row,0,tblItems[0])
self.__inputModel.setItem(row,1,tblItems[1])
self.__ui.tblListInput.setCurrentIndex(tblItems[0].index())
def __addInputInMap(self, meshName, meshObject, meshType, groupName):
"""
This function adds an entry with the specified data in the
internal map (for data management purpose).
"""
# if the entry already exists, we remove it to replace by a
# new one
if self.__dictInputData.has_key(meshName):
self.__delInputFromMap(meshName)
inputData = InputData()
inputData.meshName = meshName
inputData.meshObject = meshObject
inputData.meshType = meshType
inputData.groupName = groupName
# The key of the map is the mesh name
self.__dictInputData[meshName] = inputData
if inputData.meshType == InputData.MESHTYPES.CONCRETE:
self.__nbConcreteMesh += 1
else:
self.__nbSteelbarMesh += 1
print inputData
print "meshType = ",inputData.meshType
print "nb concrete mesh ",self.__nbConcreteMesh
print "nb steelbar mesh ",self.__nbSteelbarMesh
def onDeleteInput(self):
"""
This function is the slot connected to the Delete button. It
remove from the data list the entry selected in the Qt table.
"""
selectedIdx = self.__ui.tblListInput.selectedIndexes()
if selectedIdx:
row = selectedIdx[0].row()
tblItem = self.__inputModel.item(row,0)
meshName = str(tblItem.text())
self.__inputModel.takeRow(row)
# Don't forget to remove this entry from the mesh object
# internal dictionnary
self.__delInputFromMap(meshName)
def __delInputFromMap(self, meshName):
"""
This function removes the specified entry from the internal
map (for data management purpose)
"""
inputData = self.__dictInputData.pop(meshName)
if inputData.meshType == InputData.MESHTYPES.CONCRETE:
self.__nbConcreteMesh -= 1
else:
self.__nbSteelbarMesh -= 1
print inputData
print "nb concrete mesh ",self.__nbConcreteMesh
print "nb steelbar mesh ",self.__nbSteelbarMesh
def setData(self, listInputData=[]):
"""
This function fills the dialog widgets with values provided by
the specified data list.
"""
self.clear()
for inputData in listInputData:
meshName = inputData.meshName
meshObject = inputData.meshObject
meshType = inputData.meshType
groupName = inputData.groupName
self.__addInputInGui(meshName, meshObject, meshType, groupName)
self.__addInputInMap(meshName, meshObject, meshType, groupName)
if not DEBUG_MODE:
self.onSelectSmeshObject()
def getData(self):
"""
This function returns a list of InputData that corresponds to
the data in the dialog widgets of the current dialog.
"""
# Note that the values() function returns a copy of the list
# of values.
return self.__dictInputData.values()
def checkData(self):
"""
This function checks if the data are valid, from the dialog
window point of view.
"""
if self.__nbConcreteMesh == 0 and self.__nbSteelbarMesh == 0:
self.checkDataMessage = "You must define at least one mesh (CONCRETE or STEELBAR)"
return False
if self.__nbConcreteMesh > 1:
self.checkDataMessage = "You define multiple CONCRETE meshes."
self.checkDataMessage += "You should verify first that your version of PADDER support this configuration."
# just warn the user, but don't block
QMessageBox.information(self, "Info", self.checkDataMessage)
return True
return True
class OWConfusionMatrix(widget.OWWidget):
"""Confusion matrix widget"""
name = "Confusion Matrix"
description = "Display a confusion matrix constructed from " \
"the results of classifier evaluations."
icon = "icons/ConfusionMatrix.svg"
priority = 1001
inputs = [("Evaluation Results", Orange.evaluation.Results, "set_results")]
outputs = [("Selected Data", Orange.data.Table)]
quantities = [
"Number of instances", "Proportion of predicted",
"Proportion of actual"
]
settingsHandler = settings.ClassValuesContextHandler()
selected_learner = settings.Setting([0], schema_only=True)
selection = settings.ContextSetting(set())
selected_quantity = settings.Setting(0)
append_predictions = settings.Setting(True)
append_probabilities = settings.Setting(False)
autocommit = settings.Setting(True)
UserAdviceMessages = [
widget.Message(
"Clicking on cells or in headers outputs the corresponding "
"data instances", "click_cell")
]
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.vBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(box,
self,
"selected_learner",
"learners",
callback=self._learner_changed)
box = gui.vBox(self.controlArea, "Show")
gui.comboBox(box,
self,
"selected_quantity",
items=self.quantities,
callback=self._update)
box = gui.vBox(self.controlArea, "Select")
gui.button(box,
self,
"Select Correct",
callback=self.select_correct,
autoDefault=False)
gui.button(box,
self,
"Select Misclassified",
callback=self.select_wrong,
autoDefault=False)
gui.button(box,
self,
"Clear Selection",
callback=self.select_none,
autoDefault=False)
self.outputbox = box = gui.vBox(self.controlArea, "Output")
gui.checkBox(box,
self,
"append_predictions",
"Predictions",
callback=self._invalidate)
gui.checkBox(box,
self,
"append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit", "Send Selected",
"Send Automatically")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def sizeHint(self):
"""Initial size"""
return QSize(750, 490)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
def _init_table(self, nclasses):
item = self._item(0, 2)
item.setData("Predicted", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData("Actual", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.tableview.setItemDelegateForColumn(0, gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.tableview.setSpan(0, 2, 1, nclasses)
self.tableview.setSpan(2, 0, nclasses, 1)
font = self.tablemodel.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
for p, label in enumerate(self.headers):
for i, j in ((1, p + 2), (p + 2, 1)):
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
item.setFont(bold_font)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
if p < len(self.headers) - 1:
item.setData("br"[j == 1], BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
self._set_item(i, j, item)
hor_header = self.tableview.horizontalHeader()
if len(' '.join(self.headers)) < 120:
hor_header.setResizeMode(QHeaderView.ResizeToContents)
else:
hor_header.setDefaultSectionSize(60)
self.tablemodel.setRowCount(nclasses + 3)
self.tablemodel.setColumnCount(nclasses + 3)
def set_results(self, results):
"""Set the input results."""
prev_sel_learner = self.selected_learner.copy()
self.clear()
self.warning()
self.closeContext()
data = None
if results is not None and results.data is not None:
data = results.data
if data is not None and not data.domain.has_discrete_class:
self.warning("Confusion Matrix cannot show regression results.")
self.results = results
self.data = data
if data is not None:
class_values = data.domain.class_var.values
elif results is not None:
raise NotImplementedError
if results is None:
self.report_button.setDisabled(True)
else:
self.report_button.setDisabled(False)
nmodels = results.predicted.shape[0]
self.headers = class_values + \
[unicodedata.lookup("N-ARY SUMMATION")]
# NOTE: The 'learner_names' is set in 'Test Learners' widget.
if hasattr(results, "learner_names"):
self.learners = results.learner_names
else:
self.learners = [
"Learner #{}".format(i + 1) for i in range(nmodels)
]
self._init_table(len(class_values))
self.openContext(data.domain.class_var)
if not prev_sel_learner or prev_sel_learner[0] >= len(
self.learners):
self.selected_learner[:] = [0]
else:
self.selected_learner[:] = prev_sel_learner
self._update()
self._set_selection()
self.unconditional_commit()
def clear(self):
"""Reset the widget, clear controls"""
self.results = None
self.data = None
self.tablemodel.clear()
self.headers = []
# Clear learners last. This action will invoke `_learner_changed`
self.learners = []
def select_correct(self):
"""Select the diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
index = self.tablemodel.index(i, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_wrong(self):
"""Select the off-diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
for j in range(i + 1, n):
index = self.tablemodel.index(i, j)
selection.select(index, index)
index = self.tablemodel.index(j, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_none(self):
"""Reset selection"""
self.tableview.selectionModel().clear()
def cell_clicked(self, model_index):
"""Handle cell click event"""
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or i == j == n - 1:
selection = QItemSelection(index(2, 2), index(n - 1, n - 1))
elif i in (1, n - 1):
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j in (1, n - 1):
selection = QItemSelection(index(i, 2), index(i, n - 1))
if selection is not None:
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def commit(self):
"""Output data instances corresponding to selected cells"""
if self.results is not None and self.data is not None \
and self.selected_learner:
indices = self.tableview.selectedIndexes()
indices = {(ind.row() - 2, ind.column() - 2) for ind in indices}
actual = self.results.actual
learner_name = self.learners[self.selected_learner[0]]
predicted = self.results.predicted[self.selected_learner[0]]
selected = [
i for i, t in enumerate(zip(actual, predicted)) if t in indices
]
row_indices = self.results.row_indices[selected]
extra = []
class_var = self.data.domain.class_var
metas = self.data.domain.metas
if self.append_predictions:
predicted = numpy.array(predicted[selected], dtype=object)
extra.append(predicted.reshape(-1, 1))
var = Orange.data.DiscreteVariable(
"{}({})".format(class_var.name, learner_name),
class_var.values)
metas = metas + (var, )
if self.append_probabilities and \
self.results.probabilities is not None:
probs = self.results.probabilities[self.selected_learner[0],
selected]
extra.append(numpy.array(probs, dtype=object))
pvars = [
Orange.data.ContinuousVariable("p({})".format(value))
for value in class_var.values
]
metas = metas + tuple(pvars)
X = self.data.X[row_indices]
Y = self.data.Y[row_indices]
M = self.data.metas[row_indices]
row_ids = self.data.ids[row_indices]
M = numpy.hstack((M, ) + tuple(extra))
domain = Orange.data.Domain(self.data.domain.attributes,
self.data.domain.class_vars, metas)
data = Orange.data.Table.from_numpy(domain, X, Y, M)
data.ids = row_ids
data.name = learner_name
else:
data = None
self.send("Selected Data", data)
def _invalidate(self):
indices = self.tableview.selectedIndexes()
self.selection = {(ind.row() - 2, ind.column() - 2) for ind in indices}
self.commit()
def _set_selection(self):
selection = QItemSelection()
index = self.tableview.model().index
for row, col in self.selection:
sel = index(row + 2, col + 2)
selection.select(sel, sel)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def _learner_changed(self):
self._update()
self._set_selection()
self.commit()
def _update(self):
def _isinvalid(x):
return isnan(x) or isinf(x)
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
cmatrix = confusion_matrix(self.results, self.selected_learner[0])
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
n = len(cmatrix)
diag = numpy.diag_indices(n)
colors = cmatrix.astype(numpy.double)
colors[diag] = 0
if self.selected_quantity == 0:
normalized = cmatrix.astype(numpy.int)
formatstr = "{}"
div = numpy.array([colors.max()])
else:
if self.selected_quantity == 1:
normalized = 100 * cmatrix / colsum
div = colors.max(axis=0)
else:
normalized = 100 * cmatrix / rowsum[:, numpy.newaxis]
div = colors.max(axis=1)[:, numpy.newaxis]
formatstr = "{:2.1f} %"
div[div == 0] = 1
colors /= div
colors[diag] = normalized[diag] / normalized[diag].max()
for i in range(n):
for j in range(n):
val = normalized[i, j]
col_val = colors[i, j]
item = self._item(i + 2, j + 2)
item.setData(
"NA" if _isinvalid(val) else formatstr.format(val),
Qt.DisplayRole)
bkcolor = QColor.fromHsl(
[0, 240][i == j], 160,
255 if _isinvalid(col_val) else int(255 -
30 * col_val))
item.setData(QBrush(bkcolor), Qt.BackgroundRole)
item.setData("trbl", BorderRole)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
bold_font = self.tablemodel.invisibleRootItem().font()
bold_font.setBold(True)
def _sum_item(value, border=""):
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setFont(bold_font)
item.setData(border, BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
return item
for i in range(n):
self._set_item(n + 2, i + 2, _sum_item(int(colsum[i]), "t"))
self._set_item(i + 2, n + 2, _sum_item(int(rowsum[i]), "l"))
self._set_item(n + 2, n + 2, _sum_item(int(rowsum.sum())))
def send_report(self):
"""Send report"""
if self.results is not None and self.selected_learner:
self.report_table(
"Confusion matrix for {} (showing {})".format(
self.learners[self.selected_learner[0]],
self.quantities[self.selected_quantity].lower()),
self.tableview)
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setCentralWidget(self.ui.mangaTableView)
self.newMangaDialog = NewMangaDialog()
self.mangaDownloadDialog = MangaDownloadDialog()
self.mangaTableModel = QStandardItemModel(0, 3, self)
self.mangaTableModel.setHorizontalHeaderItem(0, QStandardItem(QString("Manga")))
self.mangaTableModel.setHorizontalHeaderItem(1, QStandardItem(QString("Latest Chapter")))
self.mangaTableModel.setHorizontalHeaderItem(2, QStandardItem(QString("Status")))
self.ui.mangaTableView.setModel(self.mangaTableModel)
newMangaAction = QAction(QIcon("./icon/add.ico"),'New Manga', self)
newMangaAction.setShortcut('Ctrl+N')
newMangaAction.triggered.connect(self.newMangaDialog.show)
removeMangaAction = QAction(QIcon("./icon/delete.ico"),'Remove Manga', self)
removeMangaAction.setShortcut('Delete')
preferencesAction = QAction(QIcon("./icon/preferences.ico"),'Preferences', self)
aboutAction = QAction(QIcon("./icon/about.ico"),'About', self)
self.ui.toolBar.addAction(newMangaAction)
self.ui.toolBar.addAction(removeMangaAction)
self.ui.toolBar.addSeparator()
self.ui.toolBar.addAction(preferencesAction)
self.ui.toolBar.addSeparator()
self.ui.toolBar.addAction(aboutAction)
self.progressBar = QProgressBar(self.ui.statusbar)
self.ui.statusbar.addPermanentWidget(self.progressBar)
self.progressBar.hide()
def closeEvent(self, QCloseEvent):
mangaList = []
for i in range(self.mangaTableModel.rowCount()):
mangaList.append({
"name" : str(self.mangaTableModel.item(i, 0).text()),
"latestChapter" : str(self.mangaTableModel.item(i, 1).text()),
"status" : "Updated",
"link" : "/trial.html"
})
self.emit(SIGNAL("applicationClosed"),mangaList)
def initializeProgressBar(self, size):
self.progressBar.setRange(0, size)
self.progressBar.setValue(0)
self.progressBar.show()
def updateProgressBar(self, value):
self.progressBar.setValue(value)
def updateStatusBar(self, msg):
self.ui.statusbar.showMessage(msg)
def updateMangaTable(self, chapter):
isFound = False
for i in range(self.mangaTableModel.rowCount()):
mangaItem = self.mangaTableModel.item(i)
if mangaItem.text() == chapter["name"]:
self.mangaTableModel.item(i, 1).setText(chapter["latestChapter"])
self.mangaTableModel.item(i, 2).setText(chapter["status"])
isFound = True
break
if not isFound:
self.addRowToMangaTable(chapter)
def addMangaListToMangaTable(self, mangaList):
for i in range(len(mangaList)):
self.addRowToMangaTable(mangaList[i])
def addRowToMangaTable(self, manga):
i = self.mangaTableModel.rowCount()
mangaItem = QStandardItem(QString(manga["name"]))
latestChapterItem = QStandardItem(QString(manga["latestChapter"]))
statusItem = QStandardItem(QString(manga["status"]))
brush = QBrush(QColor(255, 255, 255)) if i%2==0 else QBrush(QColor(200, 200, 200))
mangaItem.setBackground(brush)
latestChapterItem.setBackground(brush)
statusItem.setBackground(brush)
self.mangaTableModel.setItem(i, 0, mangaItem)
self.mangaTableModel.setItem(i, 1, latestChapterItem)
self.mangaTableModel.setItem(i, 2, statusItem)
class ConnectionsDialog(QtGui.QDialog, Ui_DlgConnections):
on_connect = pyqtSignal(str, str)
on_add = pyqtSignal(str, list)
on_connection_change = pyqtSignal()
on_zoom_change = pyqtSignal()
_connections_array = "connections"
_table_headers = OrderedDict([("ID", "id"), ("Min. Zoom", "minzoom"),
("Max. Zoom", "maxzoom"),
("Description", "description")])
_OMT = "OpenMapTiles.com"
_predefined_connections = {
_OMT: "https://free.tilehosting.com/data/v3.json?key={token}"
}
_tokens = {_OMT: "6irhAXGgsi8TrIDL0211"}
def __init__(self, default_browse_directory):
QtGui.QDialog.__init__(self)
self.setupUi(self)
self.options = OptionsGroup(self.grpOptions, self._on_zoom_change)
self.settings = QSettings("VtrSettings")
self.connections = {}
self.selected_connection = None
self.selected_layer_id = None
self.cbxConnections.currentIndexChanged['QString'].connect(
self._handle_connection_change)
self.btnCreateConnection.clicked.connect(self._create_connection)
self.btnConnect.clicked.connect(self._handle_connect)
self.btnEdit.clicked.connect(self._edit_connection)
self.btnDelete.clicked.connect(self._delete_connection)
self.btnAdd.clicked.connect(self._load_tiles_for_connection)
self.btnSave.clicked.connect(self._export_connections)
self.btnLoad.clicked.connect(self._import_connections)
self.btnHelp.clicked.connect(lambda: webbrowser.open(_HELP_URL))
self.btnBrowse.clicked.connect(self._select_file_path)
self.btnBrowseTrexCache.clicked.connect(self._select_trex_cache_folder)
self.open_path = None
self.browse_path = default_browse_directory
self.model = QStandardItemModel()
self.model.setHorizontalHeaderLabels(self._table_headers.keys())
self.tblLayers.setModel(self.model)
self._load_connections()
self._add_loaded_connections()
self.edit_connection_dialog = EditConnectionDialog()
_update_size(self)
def _select_file_path(self):
open_file_name = QFileDialog.getOpenFileName(
None, "Select Mapbox Tiles", self.browse_path,
"Mapbox Tiles (*.mbtiles)")
if open_file_name and os.path.isfile(open_file_name):
self.txtPath.setText(open_file_name)
self._handle_path_or_folder_selection(open_file_name)
def _select_trex_cache_folder(self):
open_file_name = QFileDialog.getExistingDirectory(
None, "Select t-rex Cache directory", self.browse_path)
if open_file_name and os.path.isdir(open_file_name):
self.txtTrexCachePath.setText(open_file_name)
self._handle_path_or_folder_selection(open_file_name)
def _handle_path_or_folder_selection(self, path):
self.browse_path = path
self.open_path = path
name = os.path.basename(path)
self.on_connect.emit(name, path)
def _on_zoom_change(self):
self.on_zoom_change.emit()
def set_nr_of_tiles(self, nr_tiles):
self.options.set_nr_of_tiles(nr_tiles)
def _load_tiles_for_connection(self):
indexes = self.tblLayers.selectionModel().selectedRows()
selected_layers = map(lambda i: self.model.item(i.row()).text(),
indexes)
name, url = self._get_current_connection()
self.on_add.emit(url, selected_layers)
def _export_connections(self):
file_name = QFileDialog.getSaveFileName(
None, "Export Vector Tile Reader Connections", "", "csv (*.csv)")
if file_name:
with open(file_name, 'w') as csvfile:
fieldnames = ['name', 'url']
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
for name in self.connections:
writer.writerow({
'name': name,
'url': self.connections[name]
})
def _import_connections(self):
file_name = QFileDialog.getOpenFileName(
None, "Export Vector Tile Reader Connections", "", "csv (*.csv)")
if file_name:
with open(file_name, 'r') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
self._set_connection_url(row['name'], row['url'])
self._add_loaded_connections()
def _load_connections(self):
settings = self.settings
connections = settings.beginReadArray(self._connections_array)
for i in range(connections):
settings.setArrayIndex(i)
name = settings.value("name")
url = settings.value("url")
self._set_connection_url(name, url)
settings.endArray()
def _add_loaded_connections(self):
for index, name in enumerate(self._predefined_connections.keys()):
url = self._predefined_connections[name]
self._set_connection_url(name, url)
for name in sorted(self.connections):
is_already_added = self.cbxConnections.findText(name) != -1
if not is_already_added:
self.cbxConnections.addItem(name)
if len(self.connections) > 0:
self.cbxConnections.setCurrentIndex(0)
def _delete_connection(self):
index = self.cbxConnections.currentIndex()
connection = self.cbxConnections.currentText()
msg = "Are you sure you want to remove the connection '{}' and all associated settings?".format(
connection)
reply = QMessageBox.question(self.activateWindow(), 'Confirm Delete',
msg, QMessageBox.Yes, QMessageBox.No)
if reply == QtGui.QMessageBox.Yes:
self.cbxConnections.removeItem(index)
self.connections.pop(connection)
self._save_connections()
def _save_connections(self):
settings = self.settings
settings.beginWriteArray(self._connections_array)
for index, key in enumerate(self.connections):
settings.setArrayIndex(index)
settings.setValue("name", key)
settings.setValue("url", self.connections[key])
settings.endArray()
def _set_connection_url(self, name, url):
self.connections[name] = url
def _handle_connect(self):
conn = self._get_current_connection()
name = conn[0]
url = conn[1]
self.on_connect.emit(name, url)
self.txtPath.setText("")
def _get_current_connection(self):
if self.tabServer.isEnabled():
name = self.cbxConnections.currentText()
url = self.connections[name]
elif self.tabFile.isEnabled():
url = self.txtPath.text()
name = os.path.basename(url)
else:
url = self.txtTrexCachePath.text()
name = os.path.basename(url)
if name in self._predefined_connections:
url = url.replace("{token}", self._tokens[name])
return name, url
def show(self):
self.exec_()
def keep_dialog_open(self):
return self.chkKeepOpen.isChecked()
def set_layers(self, layers):
self.model.removeRows(0, self.model.rowCount())
for row_index, layer in enumerate(layers):
for header_index, header in enumerate(self._table_headers.keys()):
header_value = self._table_headers[header]
if header_value in layer:
value = str(layer[header_value])
else:
value = "-"
self.model.setItem(row_index, header_index,
QStandardItem(value))
add_enabled = layers is not None and len(layers) > 0
self.btnAdd.setEnabled(add_enabled)
def _edit_connection(self):
conn = self._get_current_connection()
self._create_or_update_connection(name=conn[0], url=conn[1])
def _create_connection(self):
self._create_or_update_connection("", "")
def _create_or_update_connection(self, name=None, url=None):
self.edit_connection_dialog.set_name_and_path(name, url)
result = self.edit_connection_dialog.exec_()
if result == QtGui.QDialog.Accepted:
newname, newurl = self.edit_connection_dialog.get_connection()
self._set_connection_url(newname, newurl)
if newname != name:
self.cbxConnections.addItem(newname)
self.cbxConnections.setCurrentIndex(len(self.connections) - 1)
self._save_connections()
def _handle_connection_change(self, name):
self.set_layers([])
enable_connect = False
enable_edit = False
if name in self.connections:
enable_connect = True
enable_edit = name not in self._predefined_connections
self.btnConnect.setEnabled(enable_connect)
self.btnEdit.setEnabled(enable_edit)
self.btnDelete.setEnabled(enable_edit)
self.on_connection_change.emit()
class Mineral_Params(QDialog, QTableView):
def __init__(self,
Pressure=1e5,
Temperature=300,
Volume=None,
VolumeOff=True):
super(Mineral_Params, self).__init__()
self.Solidsolution = [an,ab,sp,hc,en,fs,mgts,odi,hpcen,hpcfs,di,he,cen,cats,jd,py,al,gr,mgmj,jdmj, \
capv,fo,fa,mgwa,fewa,mgri,feri,mgil,feil,co,mgpv,fepv,alpv,mppv,fppv,appv,mgcf,fecf, \
nacf,pe,wu,qtz,coes,st,an,ky,neph]
self.row = len(self.Solidsolution)
self.layout = QGridLayout(self)
self.Pressure = Pressure
self.Temperature = Temperature
self.table = QTableView()
self.model = QStandardItemModel(10, 10, self)
if Volume is None:
self.Volume = Volume
self.model.setHorizontalHeaderLabels([
'Name', 'formuala', 'Vp (km/s)', 'Vs (km/s)', 'Rho (kg/m³)',
'F (KJ/mol)', 'V (cm³/mol)', 'K (GPa)', "k'", 'θ' + '(K)', 'γ',
'q', 'G (GPa)', "G'", 'η'
])
else:
self.Volume = Volume[:-3]
self.model.setHorizontalHeaderLabels([
'Name', 'formuala', 'Vp (km/s)', 'Vs (km/s)', 'Rho (kg/m³)',
'F (KJ/mol)', 'V (cm³/mol)', 'K (GPa)', "k'", 'θ' + '(K)', 'γ',
'q', 'G (GPa)', "G'", 'η', 'Volume fraction'
])
#self.model.setHorizontalHeaderLabels(['Name','formuala','Vp (km/s)','Vs (km/s)','Rho (kg/m³)','F (KJ/mol)','V (cm³/mol)','K (GPa)',"k'",'θ'+'(K)','γ','q','G (GPa)',"G'",'η','Volume fraction'])
self.table.setModel(self.model)
self.layout.addWidget(self.table, 0, 0, 1, 5)
self.BTN()
self.table_view()
self.resize(1800, 800)
#self.restore()
def BTN(self):
return 0
self.Update = QPushButton(self)
self.Update.setText("Update")
self.Update.clicked.connect(self.update_data)
self.Update.setAutoDefault(False)
self.Restore = QPushButton(self)
self.Restore.setText("Restore")
self.Restore.clicked.connect(self.restore)
self.Restore.setAutoDefault(False)
self.Random = QPushButton(self)
self.Random.setText("Random within error")
self.Random.clicked.connect(self.random)
self.Random.setAutoDefault(False)
self.Save = QPushButton(self)
self.Save.setText("Save")
self.Save.clicked.connect(self.save)
self.Save.setAutoDefault(False)
self.Iutput = QPushButton(self)
self.Iutput.setText("Load")
self.Iutput.clicked.connect(self.iutput)
self.Iutput.setAutoDefault(False)
self.layout.addWidget(self.Update, 1, 0, 1, 1)
self.layout.addWidget(self.Restore, 1, 1, 1, 1)
self.layout.addWidget(self.Random, 1, 2, 1, 1)
self.layout.addWidget(self.Save, 1, 3, 1, 1)
self.layout.addWidget(self.Iutput, 1, 4, 1, 1)
def save(self):
options = QFileDialog.Options()
fileName = QFileDialog.getSaveFileName(
self,
"QFileDialog.getSaveFileName()",
"",
"All Files (*);;Text Files (*.txt)",
options=options)
#except:
# fileName, _= QFileDialog.getSaveFileName(self,"QFileDialog.getSaveFileName()","","All Files (*);;Text Files (*.txt)", options=options)
if PYQT == 5:
fileName = fileName[0]
else:
pass
if fileName:
file1 = open(fileName, 'w')
#print ('open',fileName)
file1.write(
'name, F_0,V_0,K_0,Kprime_0 Debye_0,grueneisen-0,q_0,G_0,Gprime_0, eta_s0 '
)
file1.write('\n')
for i in self.Solidsolution:
for j in i.parameters(self.Pressure, self.Temperature):
file1.write('{:8.8}'.format(j))
file1.write(' ')
file1.write('\n')
file1.close()
#print ('save')
def iutput(self):
fileName = QFileDialog.getOpenFileName(self, 'Open file', '/home')
if PYQT == 5:
fileName = fileName[0]
else:
pass
if fileName:
file1 = open(fileName, 'r')
next(file1)
for i, line in enumerate(file1):
line = line.split()
newItem = QStandardItem(self.Solidsolution[i].name)
self.model.setItem(i, 0, newItem)
for col in range(len(line)):
try:
string = "{:5.2f}".format(line[col])
except:
string = line[col]
item = QStandardItem(string)
self.model.setItem(i, col, item)
file1.close()
#print (string)
#print ('input')
#self.table_view()
def table_view(self):
#self.row_list=[]
for i in range(self.row):
newItem = QStandardItem(self.Solidsolution[i].name)
self.model.setItem(i, 0, newItem)
params = self.Solidsolution[i].parameters(1e5, 300)
for col in range(len(params)):
try:
string = "{:5.2f}".format(params[col])
except:
string = params[col]
item = QStandardItem(string)
self.model.setItem(i, col, item)
if self.Volume is not None:
for num, i in enumerate(self.Volume):
newItem = QStandardItem(str(self.Volume[num]))
self.model.setItem(num, 15, newItem)
def random(self):
for i in range(self.row):
newItem = QStandardItem(self.Solidsolution[i].name)
self.model.setItem(i, 0, newItem)
params = self.Solidsolution[i].parameters_random(
self.Pressure, self.Temperature)
#print ('random')
for col in range(len(params)):
try:
string = "{:5.2f}".format(params[col])
except:
string = params[col]
item = QStandardItem(string)
self.model.setItem(i, col, item)
#self.table_view()
#print ('random')
def update_data(self):
for i in range(len(self.Solidsolution)):
params = []
for j in range(15):
index = self.model.index(i, j)
params.append(self.model.itemData(index)[0])
self.Solidsolution[i].change_parameters(params)
a, b, c = self.Solidsolution[i].Vp_Vs(self.Pressure * 1e4,
self.Temperature)
c *= 1000
item = QStandardItem("{:5.2f}".format(a))
self.model.setItem(i, 2, item)
item = QStandardItem("{:5.2f}".format(b))
self.model.setItem(i, 3, item)
item = QStandardItem("{:5.2f}".format(c))
self.model.setItem(i, 4, item)
#print ('wf')
def restore(self):
try:
address = os.path.join(os.path.dirname(__file__), 'EXPDATA',
'All.txt')
self.address = address
file1 = open(address, 'r+')
except:
address = os.path.join(os.path.dirname(__file__),
'Mineral_Physics', 'EXPDATA', 'All.txt')
self.address = address
file1 = open(address, 'r')
next(file1)
for i, line in enumerate(file1):
line = line.split()
newItem = QStandardItem(self.Solidsolution[i].name)
self.model.setItem(i, 0, newItem)
for col in range(len(line)):
try:
string = "{:5.2f}".format(line[col])
except:
string = line[col]
item = QStandardItem(string)
self.model.setItem(i, col, item)
file1.close()
self.update_data()
class OWConfusionMatrix(widget.OWWidget):
name = "Confusion Matrix"
description = "Display confusion matrix constructed from results " \
"of evaluation of classifiers."
icon = "icons/ConfusionMatrix.svg"
priority = 1001
inputs = [("Evaluation Results", Orange.evaluation.Results, "set_results")]
outputs = [("Selected Data", Orange.data.Table)]
quantities = [
"Number of instances", "Proportion of predicted",
"Proportion of actual"
]
selected_learner = settings.Setting([])
selected_quantity = settings.Setting(0)
append_predictions = settings.Setting(True)
append_probabilities = settings.Setting(False)
autocommit = settings.Setting(True)
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.widgetBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(box,
self,
"selected_learner",
"learners",
callback=self._learner_changed)
box = gui.widgetBox(self.controlArea, "Show")
gui.comboBox(box,
self,
"selected_quantity",
items=self.quantities,
callback=self._update)
box = gui.widgetBox(self.controlArea, "Select")
gui.button(box,
self,
"Correct",
callback=self.select_correct,
autoDefault=False)
gui.button(box,
self,
"Misclassified",
callback=self.select_wrong,
autoDefault=False)
gui.button(box,
self,
"None",
callback=self.select_none,
autoDefault=False)
self.outputbox = box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box,
self,
"append_predictions",
"Predictions",
callback=self._invalidate)
gui.checkBox(box,
self,
"append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit", "Send Data",
"Auto send is on")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def sizeHint(self):
return QSize(750, 490)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
def set_results(self, results):
"""Set the input results."""
self.clear()
self.warning([0, 1])
data = None
if results is not None:
if results.data is not None:
data = results.data
if data is not None and not data.domain.has_discrete_class:
data = None
results = None
self.warning(
0, "Confusion Matrix cannot be used for regression results.")
self.results = results
self.data = data
if data is not None:
class_values = data.domain.class_var.values
elif results is not None:
raise NotImplementedError
if results is not None:
nmodels, ntests = results.predicted.shape
self.headers = class_values + \
[unicodedata.lookup("N-ARY SUMMATION")]
# NOTE: The 'learner_names' is set in 'Test Learners' widget.
if hasattr(results, "learner_names"):
self.learners = results.learner_names
else:
self.learners = [
"Learner #%i" % (i + 1) for i in range(nmodels)
]
item = self._item(0, 2)
item.setData("Predicted", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData("Actual", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.tableview.setItemDelegateForColumn(0,
gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.tableview.setSpan(0, 2, 1, len(class_values))
self.tableview.setSpan(2, 0, len(class_values), 1)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
for p, label in enumerate(self.headers):
for i, j in ((1, p + 2), (p + 2, 1)):
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
item.setData(QBrush(QColor(208, 208, 208)),
Qt.BackgroundColorRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
self._set_item(i, j, item)
hor_header = self.tableview.horizontalHeader()
if len(' '.join(self.headers)) < 120:
hor_header.setResizeMode(QHeaderView.ResizeToContents)
else:
hor_header.setDefaultSectionSize(60)
self.tablemodel.setRowCount(len(class_values) + 3)
self.tablemodel.setColumnCount(len(class_values) + 3)
self.selected_learner = [0]
self._update()
def clear(self):
self.results = None
self.data = None
self.tablemodel.clear()
self.headers = []
# Clear learners last. This action will invoke `_learner_changed`
# method
self.learners = []
def select_correct(self):
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
index = self.tablemodel.index(i, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_wrong(self):
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
for j in range(i + 1, n):
index = self.tablemodel.index(i, j)
selection.select(index, index)
index = self.tablemodel.index(j, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_none(self):
self.tableview.selectionModel().clear()
def cell_clicked(self, model_index):
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or i == j == n - 1:
selection = QItemSelection(index(2, 2), index(n - 1, n - 1))
elif i in (1, n - 1):
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j in (1, n - 1):
selection = QItemSelection(index(i, 2), index(i, n - 1))
if selection is not None:
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def commit(self):
if self.results is not None and self.data is not None \
and self.selected_learner:
indices = self.tableview.selectedIndexes()
indices = {(ind.row() - 2, ind.column() - 2) for ind in indices}
actual = self.results.actual
selected_learner = self.selected_learner[0]
learner_name = self.learners[selected_learner]
predicted = self.results.predicted[selected_learner]
selected = [
i for i, t in enumerate(zip(actual, predicted)) if t in indices
]
row_indices = self.results.row_indices[selected]
extra = []
class_var = self.data.domain.class_var
metas = self.data.domain.metas
if self.append_predictions:
predicted = numpy.array(predicted[selected], dtype=object)
extra.append(predicted.reshape(-1, 1))
var = Orange.data.DiscreteVariable(
"{}({})".format(class_var.name, learner_name),
class_var.values)
metas = metas + (var, )
if self.append_probabilities and \
self.results.probabilities is not None:
probs = self.results.probabilities[selected_learner, selected]
extra.append(numpy.array(probs, dtype=object))
pvars = [
Orange.data.ContinuousVariable("p({})".format(value))
for value in class_var.values
]
metas = metas + tuple(pvars)
X = self.data.X[row_indices]
Y = self.data.Y[row_indices]
M = self.data.metas[row_indices]
row_ids = self.data.ids[row_indices]
M = numpy.hstack((M, ) + tuple(extra))
domain = Orange.data.Domain(self.data.domain.attributes,
self.data.domain.class_vars, metas)
data = Orange.data.Table.from_numpy(domain, X, Y, M)
data.ids = row_ids
data.name = learner_name
else:
data = None
self.send("Selected Data", data)
def _invalidate(self):
self.commit()
def _learner_changed(self):
# The selected learner has changed
indices = self.tableview.selectedIndexes()
self._update()
selection = QItemSelection()
for sel in indices:
selection.select(sel, sel)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
self.commit()
def _update(self):
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
index = self.selected_learner[0]
cmatrix = confusion_matrix(self.results, index)
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
total = rowsum.sum()
if self.selected_quantity == 0:
value = lambda i, j: int(cmatrix[i, j])
elif self.selected_quantity == 1:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / colsum[i])
if colsum[i] else "N/A")
elif self.selected_quantity == 2:
value = lambda i, j: \
("{:2.1f} %".format(100 * cmatrix[i, j] / rowsum[i])
if colsum[i] else "N/A")
else:
assert False
for i, row in enumerate(cmatrix):
for j, _ in enumerate(row):
item = self._item(i + 2, j + 2)
item.setData(value(i, j), Qt.DisplayRole)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
model = self.tablemodel
font = model.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
def sum_item(value):
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setFont(bold_font)
return item
N = len(colsum)
for i in range(N):
model.setItem(N + 2, i + 2, sum_item(int(colsum[i])))
model.setItem(i + 2, N + 2, sum_item(int(rowsum[i])))
model.setItem(N + 2, N + 2, sum_item(int(total)))
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
uic.loadUi("mainwindow.ui", self)
model = QStandardItemModel(3, 2, self)
model.setItem(0, 0, QStandardItem(_fromUtf8("xiaoming")))
model.setItem(0, 1, QStandardItem(_fromUtf8("0")))
model.setItem(1, 0, QStandardItem(_fromUtf8("xiaogang")))
model.setItem(1, 1, QStandardItem(_fromUtf8("5")))
model.setItem(2, 0, QStandardItem(_fromUtf8("xiaohong")))
model.setItem(2, 1, QStandardItem(_fromUtf8("0")))
model.setItem(3, 0, QStandardItem(_fromUtf8("赵六")))
model.setItem(3, 1, QStandardItem(_fromUtf8("8")))
self.mapper = QDataWidgetMapper(self)
# 设置模型
self.mapper.setModel(model)
# 设置窗口部件和模型中的列的映射
self.mapper.addMapping(self.lineEdit, 0)
self.mapper.addMapping(self.lineEdit_2, 1)
# 显示模型中的第一行
self.mapper.toFirst()
#----------------------------------------------------------
tableview = QTableView()
tableview.setModel(model)
tableview.show()
class OWMPR(OWWidget):
name = 'ModelMap Projection Rank'
description = 'Ranking projections by estimating projection quality'
icon = "icons/ModelMap.svg"
inputs = [('Data', Table, 'set_data', Default)]
outputs = [('Features', AttributeList)]
want_main_area = False
settingsHandler = DomainContextHandler()
variable_changed = Signal()
def __init__(self):
super().__init__()
self.data = None
self.progress = None
self.infoa = gui.widgetLabel(self.controlArea, "No data loaded.")
self.projectionTable = QTableView()
self.controlArea.layout().addWidget(self.projectionTable)
self.projectionTable.setSelectionBehavior(QTableView.SelectRows)
self.projectionTable.setSelectionMode(QTableView.SingleSelection)
self.projectionTable.setSortingEnabled(True)
self.projectionTableModel = QStandardItemModel(self)
self.projectionTableModel.setHorizontalHeaderLabels(
["P-Index", "", ""])
self.projectionTable.setModel(self.projectionTableModel)
self.projectionTable.setColumnWidth(0, 90)
self.projectionTable.sortByColumn(0, Qt.DescendingOrder)
self.projectionTable.selectionModel().selectionChanged.connect(
self.on_selection_changed)
gui.button(self.controlArea,
self,
"Rank Projections",
callback=self.rank,
default=True)
self.resize(370, 600)
def set_data(self, data):
self.data = data
self.infoa.setText("Data set: {}".format(data.name) if self.
data else "No data loaded.")
def rank(self):
if self.progress:
return
disc = Orange.feature.discretization.EqualWidth(n=10)
ndomain = Orange.data.Domain([
disc(self.data, attr)
if type(attr) == Orange.data.variable.ContinuousVariable else attr
for attr in self.data.domain.attributes
], self.data.domain.class_vars)
t = self.data.from_table(ndomain, self.data)
attrs = t.domain.attributes
tables = {}
l = 0
self.progress = gui.ProgressBar(self,
len(attrs) * (len(attrs) - 1) / 2)
for i in range(len(attrs)):
for j in range(i):
ct = np.array(
contingency.get_contingency(t, attrs[j], attrs[i]))
pindex, _, _ = p_index(ct)
tables[i, j] = ct
item = QStandardItem()
item.setData(float(pindex), Qt.DisplayRole)
self.projectionTableModel.setItem(l, 0, item)
item = QStandardItem()
item.setData(attrs[i].name, Qt.DisplayRole)
self.projectionTableModel.setItem(l, 1, item)
item = QStandardItem()
item.setData(attrs[j].name, Qt.DisplayRole)
self.projectionTableModel.setItem(l, 2, item)
self.progress.advance()
l += 1
self.progress.finish()
self.progress = None
def on_selection_changed(self, selected, deselected):
"""Called when the ranks view selection changes."""
a1 = selected.indexes()[1].data().replace('D_', '')
a2 = selected.indexes()[2].data().replace('D_', '')
d = self.data.domain
self.send("Features", AttributeList([d[a1], d[a2]]))
class OWCorrelations(OWWidget):
name = "Correlations"
description = "Calculate correlation"
icon = "icons/correlation.svg"
inputs = [("Data", Table, 'set_data')]
outputs = [("Correlations", Table), ("Variables", AttributeList)]
def __init__(self):
super().__init__()
self.data = None
self.pairwise_correlations = True
self.correlations_type = 0
self.selected_index = None
self.changed_flag = False
self.auto_commit = True
self.splitter_state = None
self.corr_graph = CorrelationsGraph(self)
self.mainArea.layout().addWidget(self.corr_graph.plot_widget)
self.resize(1000, 500) # TODO better size handling
gui.radioButtonsInBox(
self.controlArea,
self,
"correlations_type",
("Pairwise Pearson correlation", "Pairwise Spearman correlation"),
box="Correlations",
callback=self.on_corr_type_change)
self.corr_table = CorrelationsTableView()
self.corr_model = QStandardItemModel()
self.corr_table.setModel(self.corr_model)
self.controlArea.layout().addWidget(self.corr_table)
self.corr_table.selectionModel().selectionChanged.connect(
self.on_table_selection_change)
@property
def target_variable(self):
if self.data:
return self.data.domain.class_var
else:
return None
def on_corr_type_change(self):
"""Do necessary actions after correlation type change.
Clear computed data, set selected by user variables and finally
commit(_if) changes.
"""
if self.data is not None:
curr_selection = self.selected_vars
self.clear_computed()
self.run()
if curr_selection:
try:
self.set_selected_vars(*curr_selection)
except Exception as ex:
import traceback
traceback.print_exc()
self.commit_if()
def on_table_selection_change(self, selected, deselected):
indexes = self.corr_table.selectionModel().selectedIndexes()
if indexes:
index = indexes[0]
i, j = index.row(), index.column()
if self.correlations_type == 2 and \
is_continuous(self.target_variable):
j = len(self.var_names) - 1
vars = [self.cont_vars[i], self.cont_vars[j]]
self.corr_graph.update_data(vars[0], vars[1], i, j)
else:
vars = None
self.selected_vars = vars
self.send("Variables", vars)
def clear_computed(self):
"""Clear computed data."""
self.corr_model.clear()
self.set_all_pairwise_matrix(None)
self.set_target_correlations(None, None)
def set_selected_vars(self, x, y):
"""Set selected by user variable(s)."""
x = self.cont_vars.index(x)
y = self.cont_vars.index(y)
if self.correlations_type == 2:
y = 0
model = self.corr_model
sel_model = self.corr_table.selectionModel()
sel_model.select(model.index(x, y), QItemSelectionModel.ClearAndSelect)
def set_data(self, data):
"""
Check if data has enough continuous variables.
Update data, correlation type, correlation graph and commit changes.
"""
self.clear()
self.information()
self.data = data
if data is None:
return
if len(list(filter(lambda x: x.is_continuous, data.domain))) >= 2:
self.set_variables_list(data)
self.selected_index = None
self.corr_graph.set_data(data)
if self.selected_index is None or \
any(n in self.data.domain for n in self.selected_index):
self.selected_index = self.var_names[:2]
self.run()
else:
self.data = None
self.information("Need data with at least 2 continuous variables.")
self.commit_if()
self.send("Correlations", Table(data))
def clear(self):
""" Clear all widget data. """
self.data = None
self.selected_vars = None
self.clear_graph()
def clear_graph(self):
self.corr_graph._clear_plot_widget()
self.corr_graph.set_data(None, None)
self.corr_graph.replot()
def set_variables_list(self, data):
'''
:param data: data
:return: sets cont_vars and var_names
'''
vars = list(data.domain.variables)
vars = [v for v in vars if v.is_continuous]
self.cont_vars = vars
self.var_names = [v.name for v in vars]
def run(self):
""" Start data matrix creation. """
if self.correlations_type < 2:
if self.correlations_type == 0:
matrix = pairwise_pearson_correlations(self.data,
self.cont_vars)
elif self.correlations_type == 1:
matrix = pairwise_spearman_correlations(
self.data, self.cont_vars)
self.set_all_pairwise_matrix(matrix)
elif self.target_variable and self.target_variable.is_continuous:
vars = [v for v in self.cont_vars if v != self.target_variable]
p_corr = target_pearson_correlations(self.data, vars,
self.target_variable)
s_corr = target_spearman_correlations(self.data, vars,
self.target_variable)
correlations = [list(t) for t in zip(p_corr, s_corr)]
self.set_target_correlations(correlations, vars)
def set_all_pairwise_matrix(self, matrix):
""" Set data matrix to correlations model and resize table. """
self.matrix = matrix
if matrix is not None:
for i, row in enumerate(matrix):
for j, e in enumerate(row):
item = QStandardItem()
if i != j:
item.setData(str(round(e, 5)), Qt.DisplayRole)
else:
item.setData(QColor(192, 192, 192), Qt.BackgroundRole)
self.corr_model.setItem(i, j, item)
vars = self.cont_vars
header = [v.name for v in vars]
self.corr_model.setVerticalHeaderLabels(header)
self.corr_model.setHorizontalHeaderLabels(header)
self.corr_table.resizeColumnsToContents()
self.corr_table.resizeRowsToContents()
self.corr_table.updateGeometry()
def set_target_correlations(self, correlations, vars=None):
self.target_correlations = correlations
if correlations is not None:
for i, row in enumerate(correlations):
for j, c in enumerate(row):
item = QStandardItem()
item.setData(c, Qt.DisplayRole)
self.corr_model.setItem(i, j, item)
if vars is None:
vars = self.cont_vars
v_header = [v.name for v in vars]
h_header = ["Pearson", "Spearman"]
self.corr_model.setVerticalHeaderLabels(v_header)
self.corr_model.setHorizontalHeaderLabels(h_header)
self.corr_table.resizeColumnsToContents()
self.corr_table.resizeRowsToContents()
QTimer.singleShot(100, self.corr_table.updateGeometry)
def commit_if(self):
if self.auto_commit:
self.commit()
else:
self.changed_flag = True
def commit(self):
table = None
if self.data is not None:
if self.correlations_type == 2 and self.target_variable and \
self.target_variable.is_continuous:
pearson = ContinuousVariable.make("Pearson")
spearman = ContinuousVariable.make("Spearman")
row_name = StringVariable.make("Variable")
domain = Orange.data.Domain([pearson, spearman],
metas=[row_name])
table = Orange.data.Table(domain, self.target_correlations)
for inst, name in zip(table, self.var_names):
inst[row_name] = name
self.send("Correlations", table)
def selection_changed(self): # TODO FIX IT
pass
class DlgComplexAreas(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.ui = Ui_DlgComplexAreas()
self.ui.setupUi(self)
self.stdItemModel = QStandardItemModel()
self.ui.lstAreas.setModel(self.stdItemModel)
''' buttons clicked connect '''
self.ui.btnAddPrimaryArea.clicked.connect(self.btnAddPrimaryArea_Click)
self.ui.btnAddSecondaryArea.clicked.connect(self.btnAddSecondaryArea_Click)
self.ui.btnRemove.clicked.connect(self.btnRemove_Click)
self.ui.btnCaptureTrack.clicked.connect(self.btnCaptureTrack_Click)
self.ui.buttonBoxOkCancel.accepted.connect(self.acceptEvent)
self.ui.buttonBoxOkCancel.rejected.connect(self.rejectedEvent)
self.ui.txtTrack.textChanged.connect(self.txtTrack_TextChanged)
self.ui.lstAreas.clicked.connect(self.lstAreas_Click)
self.ui.btnCaptureTrack.clicked.connect(self.captureTrack)
self.complexObstacleArea = ComplexObstacleArea()
self.itemCount = 0
self.selectedModelIndex = None
self.resultPolylineAreaListForDrawing = []
self.method_9()
self.constructionLayer = AcadHelper.createVectorLayer("TempComplexObstacleAreaLayer");
QgisHelper.appendToCanvas(define._canvas, [self.constructionLayer], "Temp")
def txtTrack_TextChanged(self):
self.complexObstacleArea[self.selectedModelIndex.row()].nominalTrack = Unit.smethod_0(float(self.ui.txtTrack.text()));
def btnAddPrimaryArea_Click(self):
if QMessageBox.question(self, "Question", "Please click \"Yes\" if you want to create new area.\nPlease click \"No\" if you want to select any area.", QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes:
# if self.comboBox.currentIndex() == ProtectionAreaType.Primary:
obstacleAreaJig= ObstacleAreaJigCreateArea(define._canvas, ProtectionAreaType.Primary)
define._canvas.setMapTool(obstacleAreaJig)
self.connect(obstacleAreaJig, SIGNAL("outputResult"), self.AreaResult)
# elif self.comboBox.currentIndex() == ProtectionAreaType.Secondary:
else:
obstacleAreaJig= ObstacleAreaJigSelectArea(define._canvas, ProtectionAreaType.Primary)
define._canvas.setMapTool(obstacleAreaJig)
self.connect(obstacleAreaJig, SIGNAL("outputResult"), self.AreaResult)
def btnAddSecondaryArea_Click(self):
if QMessageBox.question(self, "Question", "Please click \"Yes\" if you want to create new area.\nPlease click \"No\" if you want to select any area.", QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes:
# if self.comboBox.currentIndex() == ProtectionAreaType.Primary:
obstacleAreaJig= ObstacleAreaJigCreateArea(define._canvas, ProtectionAreaType.Secondary)
define._canvas.setMapTool(obstacleAreaJig)
self.connect(obstacleAreaJig, SIGNAL("outputResult"), self.AreaResult)
# elif self.comboBox.currentIndex() == ProtectionAreaType.Secondary:
else:
obstacleAreaJig= ObstacleAreaJigSelectArea(define._canvas, ProtectionAreaType.Secondary)
define._canvas.setMapTool(obstacleAreaJig)
self.connect(obstacleAreaJig, SIGNAL("outputResult"), self.AreaResult)
def AreaResult(self, area, rubberBand):
if area != None:
rubberBand.setFillColor( QColor(46, 64, 142, 100) )
rubberBand.setBorderColor( QColor(0, 10, 238) )
define._canvas.refresh()
QgisHelper.ClearRubberBandInCanvas(define._canvas)
self.complexObstacleArea.Add(area)
self.stdItemModel.setItem(self.itemCount, QStandardItem(area.ToString()))
# polygon = rubberBand.asGeometry()
# lineList = polygon.asPolygon()
# self.resultPolylineAreaListForDrawing.append(PolylineArea(lineList[0]))
self.itemCount += 1
AcadHelper.setGeometryAndAttributesInLayer(self.constructionLayer, area.PreviewArea, True)
# self.constructionLayer.startEditing()
# feature = QgsFeature()
# feature.setGeometry(QgsGeometry.fromPolyline(area.PreviewArea.method_14_closed()))
# self.constructionLayer.addFeature(feature)
# self.constructionLayer.commitChanges()
def btnRemove_Click(self):
if self.selectedModelIndex != None:
if QMessageBox.question(self, "Question", "Do you want to remove the selected item?", QMessageBox.Ok | QMessageBox.Cancel) == QMessageBox.Ok:
n = self.selectedModelIndex.row()
self.complexObstacleArea.pop(n)
self.stdItemModel.removeRow(self.selectedModelIndex.row())
self.itemCount -= 1
self.constructionLayer = AcadHelper.createVectorLayer("TempComplexObstacleAreaLayer")
for area in self.complexObstacleArea:
AcadHelper.setGeometryAndAttributesInLayer(self.constructionLayer, area.PreviewArea, True)
QgisHelper.appendToCanvas(define._canvas, [self.constructionLayer], "Temp")
QgisHelper.ClearRubberBandInCanvas(define._canvas)
pass
def btnCaptureTrack_Click(self):
pass
def acceptEvent(self):
QgisHelper.removeGroupFromName(define._mLayerTreeView, "Temp")
# for node in define._mLayerTreeView.selectedNodes( True ) :
# item = node.parent()
# item._class_ = QgsLayerTreeGroup
# if isinstance(item, QgsLayerTreeGroup):
# if node.name() == "Temp":
# node.parent().removeChildNode( node )
# QgisHelper.removeFromCanvas(define._canvas, [self.constructionLayer])
self.accept()
def rejectedEvent(self):
QgisHelper.removeGroupFromName(define._mLayerTreeView, "Temp")
self.reject()
def lstAreas_Click(self, modelIndex):
self.selectedModelIndex = modelIndex
self.method_9()
def method_9(self):
if self.selectedModelIndex == None:
self.ui.frame_Track.setVisible(False)
return
else:
selectedArea = self.complexObstacleArea[self.selectedModelIndex.row()]
QgisHelper.ClearRubberBandInCanvas(define._canvas)
rBand = QgsRubberBand(define._canvas, QGis.Polygon)
for point in selectedArea.PreviewArea.method_14_closed():
rBand.addPoint(point)
rBand.setFillColor( QColor(46, 64, 142, 100) )
rBand.setBorderColor( QColor(0, 10, 238) )
rBand.show()
if not isinstance(selectedArea, SecondaryObstacleArea) or not isinstance(selectedArea.area, SecondaryAreaStraight):
self.ui.frame_Track.setVisible(False)
return
else:
self.ui.txtTrack.setText(str(round(Unit.smethod_1(selectedArea.nominalTrack), 4)));
self.ui.frame_Track.setVisible(True)
# self.pnlTrack.Visible = true;
# selectedItem = self.lstAreas.SelectedItem as SecondaryObstacleArea;
# if (selectedItem == null || !(selectedItem.Area is SecondaryObstacleArea.SecondaryAreaStraight))
# {
# self.pnlTrack.Value = double.NaN;
# self.pnlTrack.Visible = false;
# return;
# }
# self.pnlTrack.Value = Units.smethod_1(selectedItem.NominalTrack);
# self.pnlTrack.Visible = true;
def captureTrack(self):
captureTrackTool= CaptureBearingTool(define._canvas, self.ui.txtTrack)
define._canvas.setMapTool(captureTrackTool)
class MSClusteringController(MSDialogController):
"""
Class to Control the gui and the model for clustering
"""
POS_ADDUCTS=path.normcase('config/databases/POS_ADDUCTS.csv'), \
path.normcase('config/databases/POS_ADDUCTS_LOW_RES.csv')
NEG_ADDUCTS=path.normcase('config/databases/NEG_ADDUCTS.csv'), \
path.normcase('config/databases/NEG_ADDUCTS_LOW_RES.csv')
FRAGMENTS=path.normcase('config/databases/FRAGMENTS.csv'), \
path.normcase('config/databases/FRAGMENTS_LOW_RES.csv')
def __init__(self, lspl, visu, creation):
MSDialogController.__init__(self, lspl, visu, creation)
self.polarity=1 #initialisation
if not self.model:
self.goodIdx = 0
else:
self.goodIdx = 0 if self.model[0].kind == 'HighRes' else 1
self.populateTableViews(self.polarity)
self.allAddsChecked = False
self.allFragsChecked = False
QObject.connect(self.view.posmode, SIGNAL('toggled(bool)'), self.updatePolarity)
QObject.connect(self.view.checkAllAdds, SIGNAL('clicked()'), self.checkAdds)
QObject.connect(self.view.checkAllFrags, SIGNAL('clicked()'), self.checkFrags)
self.view.exec_()
def getFragAddData(self, polarity=1):
"""parsing adducts and fragments files"""
frags=self.readData(self.FRAGMENTS[self.goodIdx])
if not polarity:
adds=self.readData(self.NEG_ADDUCTS[self.goodIdx])
elif polarity:
adds=self.readData(self.POS_ADDUCTS[self.goodIdx])
return frags, adds
def readData(self, file_):
"""read data from databases files"""
def fragData(line, d):
d[(s[0], s[1], str(1))]= False
def addData(line, d):
d[(s[0], s[-1].rstrip(), s[1])]= False
routine=None
if file_ in (self.POS_ADDUCTS+self.NEG_ADDUCTS):
routine=addData
elif file_ in self.FRAGMENTS:
routine=fragData
else:
print ("Error reading adducts and fragments files")
return
res=OrderedDict()
with open(file_) as f:
for i in range (2):
l=f.readline()
while l!="":
s=l.split(',')
routine(l, res)
l=f.readline()
return res
def checkAdds(self):
for i in xrange(self.adductsModel.rowCount()):
#data = self.adductsModel.item(i,0).text()
item = self.adductsModel.item(i,0)
if self.allAddsChecked:
item.setCheckState(0)
self.view.checkAllAdds.setText('Check All')
else:
item.setCheckState(2)
self.view.checkAllAdds.setText('UnCheck All')
self.allAddsChecked = not self.allAddsChecked
def checkFrags(self):
for i in xrange(self.fragsModel.rowCount()):
#data = self.fragsModel.item(i,0).text()
item = self.fragsModel.item(i,0)
if self.allFragsChecked:
item.setCheckState(0)
self.view.checkAllFrags.setText('Check All')
else:
item.setCheckState(2)
self.view.checkAllFrags.setText('UnCheck All')
self.allFragsChecked = not self.allFragsChecked
def populateTableViews(self, polarity):
frags, adds = self.getFragAddData(polarity)
self.adductsModel, self.fragsModel = QStandardItemModel(), QStandardItemModel()
self.adductsModel.setHorizontalHeaderLabels(["Adducts(name, mass, nmol)"])
self.fragsModel.setHorizontalHeaderLabels(["Fragments(name, mass, nmol)"])
for i, adduct in enumerate(adds.keys()):
item =QStandardItem(', '.join(map(str, adduct)))
item.setCheckable(True)
if adds[adduct]:
item.setCheckState(2)
else:
item.setCheckState(0)
self.adductsModel.setItem(i, 0, item)
self.view.adductsTable.setModel(self.adductsModel)
for i, frag in enumerate(frags.keys()):
item = QStandardItem(', '.join(map(str, frag)))
item.setCheckable(True)
if frags[frag]:
item.setCheckState(2)
else:
item.setCheckState(0)
self.fragsModel.setItem(i, 0, item)
self.view.fragTable.setModel(self.fragsModel)
def getFragsAndAdductsToCheck(self):
frags, adducts={}, {}
for i in range(self.fragsModel.rowCount()):
data = self.fragsModel.item(i,0).text()
item = self.fragsModel.item(i,0)
if item.checkState():
frags[tuple([str(x) for x in data.split(', ')])]= True
else:
frags[tuple([str(x) for x in data.split(', ')])]= False
for i in range(self.adductsModel.rowCount()):
data = self.adductsModel.item(i,0).text()
item = self.adductsModel.item(i,0)
if item.checkState():
adducts[tuple([str(x) for x in data.split(', ')])]= True
else:
adducts[tuple([str(x) for x in data.split(', ')])]= False
checkMasses=OrderedDict()
for frag in frags.keys():
if frags[frag]:
checkMasses[(float(frag[1]), float(frag[2]))] = frag[0]
for add in adducts.keys():
if adducts[add]:
if self.polarity:#positive polarity
checkMasses[(-float(add[1]), float(add[2]))] = add[0]
elif not self.polarity:#negative polarity
checkMasses[(float(add[1]), float(add[2]))] = add[0]
return checkMasses
def updatePolarity(self, boolean):
self.polarity = 1 if boolean else 0#positive, negative
self.populateTableViews(self.polarity)
def getParameters(self):
"""classical getParameters (model) function"""
self.parameters["rtError"] = self.view.lineEdit_2.value()
self.parameters["clusterLength"] = self.view.lineEdit_3.value()
self.parameters["idmsLength"] =tuple([float(x) for x in self.view.lineEdit_4.text().split('-')])
self.parameters["badPeaks"] = self.view.lineEdit_5.isChecked()
#self.parameters["useCorr"] = self.view.check.isChecked()
self.parameters["gap"]=self.view.spinBox.value()
self.parameters["resolveConflicts"]=self.view.lineEdit_6.isChecked()
self.parameters["frags"]=self.getFragsAndAdductsToCheck()
def startTask(self):
"""
Main Function (model function) Clustering
"""
MSDialogController.startTask(self)
#qApp.instance().view.showInStatusBar("Clustering Step...Please Wait..", 5000)
self.task = MSClusterThread(self.sampleList, **self.parameters)
QObject.connect(self.view, SIGNAL('destroyed(QObject *)'), self.task.begin)
#self.connect(self.view, SIGNAL('destroyed(QObject *)'), self.setViewToNone)
QObject.connect(self.task, SIGNAL("started()"),qApp.instance().view.to_determined_mode)
QObject.connect(self.task, SIGNAL('update_pb'), qApp.instance().view.updateProgressBar)
#QObject.connect(self.task, SIGNAL("finished()"),qApp.instance().view.to_determined_mode)
QObject.connect(self.task, SIGNAL("finished()"), self.setModels)
#print "about to close"
self.view.close()
#print "closed"
#self.task.begin()
def setModels(self):#, sampleList):
"""
closing function of the process
"""
qApp.instance().view.showInformationMessage("Clustering done", "Clustering Done succesfully !")
qApp.instance().view.tabWidget.setCurrentIndex(2)
def _initialize(self):
"""initialization of the parameters"""
self.view.lineEdit_2.setValue(6.)
self.view.lineEdit_3.setValue(6)
self.view.lineEdit_4.setText("0-0")
#self.view.lineEdit_5.setText("10.")
self.view.decrOrder.setChecked(True)
self.view.lineEdit_6.setChecked(True)
self.view.spinBox.setValue(0)
class OWMPR(OWWidget):
name = 'ModelMap Projection Rank'
description = 'Ranking projections by estimating projection quality'
icon = "icons/ModelMap.svg"
inputs = [('Data', Table, 'set_data', Default)]
outputs = [('Features', AttributeList)]
want_main_area = False
settingsHandler = DomainContextHandler()
variable_changed = Signal()
def __init__(self):
super().__init__()
self.data = None
self.progress = None
self.infoa = gui.widgetLabel(self.controlArea, "No data loaded.")
self.projectionTable = QTableView()
self.controlArea.layout().addWidget(self.projectionTable)
self.projectionTable.setSelectionBehavior(QTableView.SelectRows)
self.projectionTable.setSelectionMode(QTableView.SingleSelection)
self.projectionTable.setSortingEnabled(True)
self.projectionTableModel = QStandardItemModel(self)
self.projectionTableModel.setHorizontalHeaderLabels(["P-Index", "", ""])
self.projectionTable.setModel(self.projectionTableModel)
self.projectionTable.setColumnWidth(0, 90)
self.projectionTable.sortByColumn(0, Qt.DescendingOrder)
self.projectionTable.selectionModel().selectionChanged.connect(self.on_selection_changed)
gui.button(self.controlArea, self, "Rank Projections", callback=self.rank, default=True)
self.resize(370, 600)
def set_data(self, data):
self.data = data
self.infoa.setText("Data set: {}".format(data.name) if self.data else "No data loaded.")
def rank(self):
if self.progress:
return
disc = Orange.preprocess.discretize.EqualWidth(n=10)
ndomain = Orange.data.Domain(
[disc(self.data, attr) if type(attr) == Orange.data.variable.ContinuousVariable
else attr for attr in self.data.domain.attributes], self.data.domain.class_vars)
t = self.data.from_table(ndomain, self.data)
attrs = t.domain.attributes
tables = {}
l = 0
self.progress = gui.ProgressBar(self, len(attrs) * (len(attrs) - 1) / 2)
for i in range(len(attrs)):
for j in range(i):
ct = np.array(contingency.get_contingency(t, attrs[j], attrs[i]))
pindex, _, _ = p_index(ct)
tables[i, j] = ct
item = QStandardItem()
item.setData(float(pindex), Qt.DisplayRole)
self.projectionTableModel.setItem(l, 0, item)
item = QStandardItem()
item.setData(attrs[i].name, Qt.DisplayRole)
self.projectionTableModel.setItem(l, 1, item)
item = QStandardItem()
item.setData(attrs[j].name, Qt.DisplayRole)
self.projectionTableModel.setItem(l, 2, item)
self.progress.advance()
l += 1
self.progress.finish()
self.progress = None
def on_selection_changed(self, selected, deselected):
"""Called when the ranks view selection changes."""
a1 = selected.indexes()[1].data().replace('D_', '')
a2 = selected.indexes()[2].data().replace('D_', '')
d = self.data.domain
self.send("Features", AttributeList([d[a1], d[a2]]))
class PosiviewProperties(QgsOptionsDialogBase, Ui_PosiviewPropertiesBase):
'''
GUI class classdocs for the Configuration dialog
'''
applyChanges = pyqtSignal(dict)
def __init__(self, project, parent=None):
'''
Setup dialog widgets with the project properties
'''
super(PosiviewProperties, self).__init__("PosiViewProperties", parent)
self.setupUi(self)
self.groupBox_6.hide()
self.initOptionsBase(False)
self.restoreOptionsBaseUi()
self.comboBoxParser.addItems(PARSERS)
self.comboBoxProviderType.addItems(DEVICE_TYPES)
self.project = project
self.projectProperties = project.properties()
self.mToolButtonLoad.setDefaultAction(self.actionLoadConfiguration)
self.mToolButtonSave.setDefaultAction(self.actionSaveConfiguration)
self.mobileModel = QStringListModel()
self.mobileListModel = QStringListModel()
self.mMobileListView.setModel(self.mobileListModel)
self.mobileProviderModel = QStandardItemModel()
self.mobileProviderModel.setHorizontalHeaderLabels(('Provider', 'Filter'))
self.mMobileProviderTableView.setModel(self.mobileProviderModel)
self.providerListModel = QStringListModel()
self.mDataProviderListView.setModel(self.providerListModel)
self.comboBoxProviders.setModel(self.providerListModel)
self.setupModelData(self.projectProperties)
self.setupGeneralData(self.projectProperties)
def setupModelData(self, properties):
self.mobileListModel.setStringList(sorted(properties['Mobiles'].keys()))
self.providerListModel.setStringList(sorted(properties['Provider'].keys()))
def setupGeneralData(self, properties):
self.lineEditCruise.setText(properties['Mission']['cruise'])
self.lineEditDive.setText(properties['Mission']['dive'])
self.lineEditStation.setText(properties['Mission']['station'])
self.lineEditRecorderPath.setText(properties['RecorderPath'])
self.checkBoxAutoRecording.setChecked(properties['AutoRecord'])
self.spinBoxNotifyDuration.setValue(properties['NotifyDuration'])
self.checkBoxUtcClock.setChecked((properties['ShowUtcClock']))
def updateGeneralData(self):
self.projectProperties['Mission']['cruise'] = self.lineEditCruise.text()
self.projectProperties['Mission']['dive'] = self.lineEditDive.text()
self.projectProperties['Mission']['station'] = self.lineEditStation.text()
self.projectProperties['RecorderPath'] = self.lineEditRecorderPath.text()
self.projectProperties['AutoRecord'] = self.checkBoxAutoRecording.isChecked()
self.projectProperties['NotifyDuration'] = self.spinBoxNotifyDuration.value()
self.projectProperties['ShowUtcClock'] = self.checkBoxUtcClock.isChecked()
def getColor(self, value):
try:
return QColor.fromRgba(int(value))
except ValueError:
return QColor(value)
@pyqtSlot(QAbstractButton, name='on_buttonBox_clicked')
def onButtonBoxClicked(self, button):
role = self.buttonBox.buttonRole(button)
if role == QDialogButtonBox.ApplyRole or role == QDialogButtonBox.AcceptRole:
self.updateGeneralData()
self.applyChanges.emit(self.projectProperties)
@pyqtSlot(name='on_actionSaveConfiguration_triggered')
def onActionSaveConfigurationTriggered(self):
''' Save the current configuration
'''
fn = QFileDialog.getSaveFileName(None, 'Save PosiView configuration', '', 'Configuration (*.ini *.conf)')
self.project.store(fn)
@pyqtSlot(name='on_actionLoadConfiguration_triggered')
def onActionLoadConfigurationTriggered(self):
''' Load configuration from file
'''
fn = QFileDialog.getOpenFileName(None, 'Save PosiView configuration', '', 'Configuration (*.ini *.conf)')
self.projectProperties = self.project.read(fn)
self.setupModelData(self.projectProperties)
self.setupGeneralData(self.projectProperties)
@pyqtSlot(QModelIndex, name='on_mMobileListView_clicked')
def editMobile(self, index):
''' Populate the widgets with the selected mobiles properties
'''
if index.isValid():
self.populateMobileWidgets(index)
@pyqtSlot(str, name='on_comboBoxMobileType_currentIndexChanged')
def mobileTypeChanged(self, mType):
if mType == 'SHAPE':
# self.lineEditMobileShape.setText(str(mobile['shape']))
self.lineEditMobileShape.setEnabled(True)
else:
self.lineEditMobileShape.setEnabled(False)
@pyqtSlot(QModelIndex, name='on_mMobileListView_activated')
def activated(self, index):
pass
@pyqtSlot(name='on_toolButtonAddMobile_clicked')
def addMobile(self):
self.mobileListModel.insertRow(self.mobileListModel.rowCount())
index = self.mobileListModel.index(self.mobileListModel.rowCount() - 1)
self.lineEditMobileName.setText('NewMobile')
self.mobileListModel.setData(index, 'NewMobile', Qt.DisplayRole)
self.mMobileListView.setCurrentIndex(index)
self.applyMobile()
@pyqtSlot(name='on_pushButtonApplyMobile_clicked')
def applyMobile(self):
index = self.mMobileListView.currentIndex()
if index.isValid() and not self.lineEditMobileName.text() == '':
mobile = dict()
mobile['Name'] = self.lineEditMobileName.text()
mobile['type'] = self.comboBoxMobileType.currentText()
try:
t = eval(self.lineEditMobileShape.text())
if t.__class__ is tuple or t.__class__ is dict:
mobile['shape'] = t
except SyntaxError:
mobile['shape'] = ((0.0, -0.5), (0.3, 0.5), (0.0, 0.2), (-0.5, 0.5))
mobile['length'] = self.doubleSpinBoxMobileLength.value()
mobile['width'] = self.doubleSpinBoxMobileWidth.value()
mobile['zValue'] = self.spinBoxZValue.value()
mobile['color'] = self.mColorButtonMobileColor.color().rgba()
mobile['fillColor'] = self.mColorButtonMobileFillColor.color().rgba()
mobile['timeout'] = self.spinBoxMobileTimeout.value() * 1000
mobile['nofixNotify'] = self.spinBoxMobileNotification.value()
mobile['trackLength'] = self.spinBoxTrackLength.value()
mobile['trackColor'] = self.mColorButtonMobileTrackColor.color().rgba()
provs = dict()
for r in range(self.mobileProviderModel.rowCount()):
try:
fil = int(self.mobileProviderModel.item(r, 1).data(Qt.DisplayRole))
except:
fil = self.mobileProviderModel.item(r, 1).data(Qt.DisplayRole)
if not fil:
fil = None
provs[self.mobileProviderModel.item(r, 0).data(Qt.DisplayRole)] = fil
mobile['provider'] = provs
currName = self.mobileListModel.data(index, Qt.DisplayRole)
if not currName == mobile['Name']:
del self.projectProperties['Mobiles'][currName]
self.mobileListModel.setData(index, mobile['Name'], Qt.DisplayRole)
self.projectProperties['Mobiles'][mobile['Name']] = mobile
def populateMobileWidgets(self, index):
mobile = self.projectProperties['Mobiles'][self.mobileListModel.data(index, Qt.DisplayRole)]
self.lineEditMobileName.setText(mobile.get('Name'))
self.comboBoxMobileType.setCurrentIndex(self.comboBoxMobileType.findText(mobile.setdefault('type', 'BOX').upper()))
if mobile['type'] == 'SHAPE':
self.lineEditMobileShape.setText(str(mobile['shape']))
self.lineEditMobileShape.setEnabled(True)
else:
self.lineEditMobileShape.setEnabled(False)
self.lineEditMobileShape.clear()
self.doubleSpinBoxMobileLength.setValue(mobile.get('length', 20.0))
self.doubleSpinBoxMobileWidth.setValue(mobile.get('width', 5.0))
self.spinBoxZValue.setValue(mobile.get('zValue', 100))
self.mColorButtonMobileColor.setColor(self.getColor(mobile.get('color', 'black')))
self.mColorButtonMobileFillColor.setColor(self.getColor(mobile.get('fillColor', 'green')))
self.spinBoxMobileTimeout.setValue(mobile.get('timeout', 3000) / 1000)
self.spinBoxMobileNotification.setValue(mobile.get('nofixNotify', 0))
self.spinBoxTrackLength.setValue(mobile.get('trackLength', 100))
self.mColorButtonMobileTrackColor.setColor(self.getColor(mobile.get('trackColor', 'green')))
r = 0
self.mobileProviderModel.removeRows(0, self.mobileProviderModel.rowCount())
if 'provider' in mobile:
for k, v in mobile['provider'].items():
prov = QStandardItem(k)
val = QStandardItem(str(v))
self.mobileProviderModel.setItem(r, 0, prov)
self.mobileProviderModel.setItem(r, 1, val)
r += 1
@pyqtSlot(name='on_toolButtonRemoveMobile_clicked')
def removeMobile(self):
idx = self.mMobileListView.currentIndex()
if idx.isValid():
self.projectProperties['Mobiles'].pop(self.mobileListModel.data(idx, Qt.DisplayRole))
self.mobileListModel.removeRows(idx.row(), 1)
idx = self.mMobileListView.currentIndex()
if idx.isValid():
self.populateMobileWidgets(idx)
@pyqtSlot(name='on_toolButtonRefreshMobileProvider_clicked')
def refreshMobileProvider(self):
prov = self.comboBoxProviders.currentText()
if prov == '':
return
fil = None
if self.lineEditProviderFilter.text() != '':
fil = self.lineEditProviderFilter.text()
items = self.mobileProviderModel.findItems(prov, Qt.MatchExactly, 0)
if items:
for item in items:
self.mobileProviderModel.setItem(item.row(), 1, QStandardItem(fil))
else:
self.mobileProviderModel.appendRow([QStandardItem(prov), QStandardItem(fil)])
@pyqtSlot(name='on_toolButtonRemoveMobileProvider_clicked')
def removeMobileProvider(self):
idx = self.mMobileProviderTableView.currentIndex()
if idx.isValid():
self.mobileProviderModel.removeRow(idx.row())
@pyqtSlot(name='on_pushButtonApplyDataProvider_clicked')
def applyDataProvider(self):
index = self.mDataProviderListView.currentIndex()
if index.isValid() and not self.lineEditProviderName.text() == '':
provider = dict()
provider['Name'] = self.lineEditProviderName.text()
provider['DataDeviceType'] = self.comboBoxProviderType.currentText()
if provider['DataDeviceType'] in NETWORK_TYPES:
provider['Host'] = self.lineEditProviderHostName.text()
provider['Port'] = self.spinBoxProviderPort.value()
provider['Parser'] = self.comboBoxParser.currentText()
currName = self.providerListModel.data(index, Qt.DisplayRole)
if not currName == provider['Name']:
del self.projectProperties['Provider'][currName]
self.providerListModel.setData(index, provider['Name'], Qt.DisplayRole)
self.projectProperties['Provider'][provider['Name']] = provider
@pyqtSlot(QModelIndex, name='on_mDataProviderListView_clicked')
def editDataProvider(self, index):
'''
'''
if index.isValid():
self.populateDataProviderWidgets(index)
def populateDataProviderWidgets(self, index):
provider = self.projectProperties['Provider'][self.providerListModel.data(index, Qt.DisplayRole)]
self.lineEditProviderName.setText(provider.get('Name'))
self.comboBoxProviderType.setCurrentIndex(self.comboBoxProviderType.findText(provider.setdefault('DataDeviceType', 'UDP').upper()))
if provider['DataDeviceType'] in NETWORK_TYPES:
self.stackedWidgetDataDevice.setCurrentIndex(0)
self.lineEditProviderHostName.setText(provider.setdefault('Host', '0.0.0.0'))
self.spinBoxProviderPort.setValue(int(provider.setdefault('Port', 2000)))
self.comboBoxParser.setCurrentIndex(self.comboBoxParser.findText(provider.setdefault('Parser', 'NONE').upper()))
@pyqtSlot(name='on_toolButtonAddDataProvider_clicked')
def addDataProvider(self):
self.providerListModel.insertRow(self.providerListModel.rowCount())
index = self.providerListModel.index(self.providerListModel.rowCount() - 1)
self.lineEditProviderName.setText('NewDataProvider')
self.providerListModel.setData(index, 'NewDataProvider', Qt.DisplayRole)
self.mDataProviderListView.setCurrentIndex(index)
self.applyDataProvider()
@pyqtSlot(name='on_toolButtonRemoveDataProvider_clicked')
def removeDataProvider(self):
idx = self.mDataProviderListView.currentIndex()
if idx.isValid():
self.projectProperties['Provider'].pop(self.providerListModel.data(idx, Qt.DisplayRole))
self.providerListModel.removeRows(idx.row(), 1)
idx = self.mDataProviderListView.currentIndex()
if idx.isValid():
self.populateDataProviderWidgets(idx)
@pyqtSlot(name='on_toolButtonSelectLogPath_clicked')
def selectRecorderPath(self):
path = QFileDialog.getExistingDirectory(self, self.tr('Select Recorder Path'), self.lineEditRecorderPath.text(),
QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks)
if path != '':
self.lineEditRecorderPath.setText(path)
@pyqtSlot(QPoint, name='on_lineEditMobileShape_customContextMenuRequested')
def mobileShapeContextMenu(self, pos):
menu = QMenu(self.lineEditMobileShape)
vesselAction = menu.addAction(self.tr('Vessel'))
rovAction = menu.addAction(self.tr('ROV'))
auvAction = menu.addAction(self.tr('AUV'))
arrowAction = menu.addAction(self.tr('Arrow'))
selectedAction = menu.exec_(self.lineEditMobileShape.mapToGlobal(pos))
if selectedAction == vesselAction:
self.lineEditMobileShape.setText(u'((0, -0.5), (0.5, -0.3), (0.5, 0.5), (-0.5, 0.5), (-0.5, -0.3))')
elif selectedAction == rovAction:
self.lineEditMobileShape.setText(u'((0.3, -0.5), (0.5, -0.3), (0.5, 0.5), (-0.5, 0.5), (-0.5, -0.3), (-0.3, -0.5))')
elif selectedAction == auvAction:
self.lineEditMobileShape.setText(u'((0, -0.5), (0.5, -0.3), (0.5, 0.5), (-0.5, 0.5), (-0.5, -0.3))')
elif selectedAction == arrowAction:
self.lineEditMobileShape.setText(u'((0, -0.5), (0.5, 0.5), (0, 0), (-0.5, 0.5))')
@pyqtSlot(name='on_buttonBox_helpRequested')
def showHelp(self):
"""Display application help to the user."""
help_file = os.path.join(os.path.split(os.path.dirname(__file__))[0], 'help', 'index.html')
QDesktopServices.openUrl(QUrl.fromLocalFile(help_file))
