예제 #1
0
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)
예제 #2
0
 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
예제 #3
0
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)
예제 #4
0
 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
예제 #5
0
파일: random9.py 프로젝트: harshn05/WIP
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)
예제 #6
0
파일: random9.py 프로젝트: harshn05/WIP
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)
예제 #7
0
    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)
예제 #8
0
    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)
예제 #9
0
파일: Search.py 프로젝트: rmasad/Caldo
  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
예제 #10
0
    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)
예제 #11
0
    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)
예제 #12
0
    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)
예제 #13
0
    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
예제 #14
0
 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
예제 #15
0
    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)
예제 #16
0
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)
예제 #17
0
파일: queue.py 프로젝트: urkh/Turpial
    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()
예제 #18
0
파일: queue.py 프로젝트: Bouska/Turpial
    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()
예제 #19
0
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
예제 #20
0
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)
예제 #22
0
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)
예제 #23
0
파일: gps.py 프로젝트: Tinkerforge/brickv
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)
예제 #24
0
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_()
예제 #25
0
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
예제 #26
0
    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()"""
예제 #27
0
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)
예제 #28
0
파일: gps_v2.py 프로젝트: jose1711/brickv
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)
예제 #29
0
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)
예제 #30
0
    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
예제 #31
0
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)
예제 #32
0
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()
예제 #34
0
    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_())

예제 #35
0
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)
예제 #36
0
        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_())
예제 #37
0
    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
예제 #38
0
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)
예제 #39
0
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)))
예제 #40
0
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_()
예제 #41
0
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
예제 #42
0
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)
예제 #43
0
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()
예제 #45
0
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()
예제 #46
0
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)))
예제 #47
0
    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()
예제 #48
0
파일: owmpr.py 프로젝트: thatcher/orange3
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)
예제 #51
0
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)
예제 #52
0
파일: owmpr.py 프로젝트: Micseb/orange3
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]]))
예제 #53
0
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))