def restoreState(self,layer,table):
        if layer.id() in self.states.keys():
            table.blockSignals(True)
            #clear dock widget
            while table.rowCount()>0:
                table.removeRow(0)
            #add rows
            table.setRowCount(len(self.states[layer.id()]))
            for n in range(0, len(self.states[layer.id()])):
                row = self.states[layer.id()][n]
                #set first column as checkbox
                item=QTableWidgetItem()
                item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
                if row[0]:
                    item.setCheckState(Qt.Checked)
                else:
                    item.setCheckState(Qt.Unchecked)
                item.setText("")
                table.setItem(n,0,item)
                #set second column as combobox
                combo = QComboBox();
                combo.addItems(row[1])
                #print (row[1],row[2])
                combo.setCurrentIndex(row[2])
                table.setCellWidget(n,1,combo)
                #set third column as attribute value
                item = QTableWidgetItem(row[3])
                item.setData(Qt.DisplayRole,row[4])
                if row[5]:
                    item.setForeground(QBrush(QColor(0,0,0)))
                else:
                    item.setForeground(QBrush(QColor(130,130,130)))
                if row[6]:
                    item.setBackground(QBrush(QColor(183,213,225)))
                table.setItem(n,2,item)

            table.blockSignals(False)
            return True

        else:
            return None
Exemplo n.º 2
0
def addSelectedIdentifyDataToTableWidget(IdentifySelectedDialog, setupObject, selectedPUDetailsDict):
    featIDList = list(setupObject.targetDict.keys())
    featIDList.sort()
    for rowNumber in range(0, len(featIDList)):
        featID = featIDList[rowNumber]
        IdentifySelectedDialog.identifySelectedTableWidget.insertRow(rowNumber)
        featIDTableItem = QTableWidgetItem(str(featID))
        featNameTableItem = QTableWidgetItem(str(setupObject.targetDict[featID][0]))
        avaIDTableItem = QTableWidgetItem(str(returnStringAmountPerStatus(setupObject, selectedPUDetailsDict, 'Available', featID)))
        conIDTableItem = QTableWidgetItem(str(returnStringAmountPerStatus(setupObject, selectedPUDetailsDict, 'Conserved', featID)))
        earIDTableItem = QTableWidgetItem(str(returnStringAmountPerStatus(setupObject, selectedPUDetailsDict, 'Earmarked', featID)))
        exlIDTableItem = QTableWidgetItem(str(returnStringAmountPerStatus(setupObject, selectedPUDetailsDict, 'Excluded', featID)))
        featTarget = returnRoundedValue(setupObject, setupObject.targetDict[featID][3])
        featTargetTableItem = QTableWidgetItem(featTarget)
        featShortfallTableItem = QTableWidgetItem(returnStringShortfall(setupObject, featID))

        IdentifySelectedDialog.identifySelectedTableWidget.setItem(rowNumber, 0, featIDTableItem)
        IdentifySelectedDialog.identifySelectedTableWidget.setItem(rowNumber, 1, featNameTableItem)
        IdentifySelectedDialog.identifySelectedTableWidget.setItem(rowNumber, 2, avaIDTableItem)
        conIDTableItem.setForeground(QColor.fromRgb(0, 153, 51))
        IdentifySelectedDialog.identifySelectedTableWidget.setItem(rowNumber, 3, conIDTableItem)
        earIDTableItem.setForeground(QColor.fromRgb(51, 204, 51))
        IdentifySelectedDialog.identifySelectedTableWidget.setItem(rowNumber, 4, earIDTableItem)
        IdentifySelectedDialog.identifySelectedTableWidget.setItem(rowNumber, 5, exlIDTableItem)
        IdentifySelectedDialog.identifySelectedTableWidget.setItem(rowNumber, 6, featTargetTableItem)
        if returnStringShortfall(setupObject, featID) == 'Target met':
            featShortfallTableItem.setForeground(QColor.fromRgb(128, 128, 128))
        IdentifySelectedDialog.identifySelectedTableWidget.setItem(rowNumber, 7, featShortfallTableItem)
def addIdentifyDataToTableWidget(identifyTableWidget, setupObject,
                                 targetMetDict, identDict):
    featIDList = list(identDict.keys())
    featIDList.sort()
    for aRow in range(0, len(featIDList)):
        identifyTableWidget.insertRow(aRow)
        featID = featIDList[aRow]
        featIdentifyList = identDict[featID]
        for aCol in range(0, len(featIdentifyList)):
            featValue = featIdentifyList[aCol]
            featIDItem = QTableWidgetItem(featValue)
            if aCol == 6:
                targetMetStatus = targetMetDict[featID]
                if targetMetStatus == 'Met':
                    featIDItem.setForeground(QColor.fromRgb(0, 102, 51))
                elif targetMetStatus == 'Not met':
                    featIDItem.setForeground(QColor.fromRgb(255, 0, 0))
                else:
                    featIDItem.setForeground(QColor.fromRgb(128, 128, 128))
            identifyTableWidget.setItem(aRow, aCol, featIDItem)

    identifyTableWidget.horizontalHeader().setStyleSheet(
        setupObject.TableHeadingStyle)
    identifyTableWidget.verticalHeader().hide()
Exemplo n.º 4
0
def update_srs_table_content(dockwidget, srs_table):
    with block_signals_to(dockwidget.QTableW_StraRS):
        # init table
        dockwidget.QTableW_StraRS.setRowCount(srs_table["row_count"])
        dockwidget.QTableW_StraRS.setColumnCount(srs_table["column_count"])

        # enter data onto Table
        for n, key in enumerate(srs_table["header"]):
            if key == "Pix Val":
                for m, item in enumerate(
                        srs_table["color_table"]["Pixel Value"]):
                    item_table = QTableWidgetItem(str(item))
                    item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
                    item_table.setTextAlignment(Qt.AlignCenter
                                                | Qt.AlignVCenter)
                    dockwidget.QTableW_StraRS.setItem(m, n, item_table)
            if key == "Color":
                for m in range(srs_table["row_count"]):
                    item_table = QTableWidgetItem()
                    item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
                    item_table.setBackground(
                        QColor(srs_table["color_table"]["Red"][m],
                               srs_table["color_table"]["Green"][m],
                               srs_table["color_table"]["Blue"][m],
                               srs_table["color_table"]["Alpha"][m]))
                    dockwidget.QTableW_StraRS.setItem(m, n, item_table)
            if key == "Num Samples":
                for m in range(srs_table["row_count"]):
                    item_table = QTableWidgetItem(srs_table["num_samples"][m])
                    item_table.setTextAlignment(Qt.AlignCenter
                                                | Qt.AlignVCenter)
                    if not srs_table["On"][m]:
                        item_table.setForeground(QColor("lightGrey"))
                        item_table.setFlags(Qt.ItemIsSelectable
                                            | Qt.ItemIsEnabled)
                    dockwidget.QTableW_StraRS.setItem(m, n, item_table)
            if key == "Std Error":
                for m in range(srs_table["row_count"]):
                    item_table = QTableWidgetItem(srs_table["std_error"][m])
                    item_table.setTextAlignment(Qt.AlignCenter
                                                | Qt.AlignVCenter)
                    if not srs_table["On"][m]:
                        item_table.setForeground(QColor("lightGrey"))
                        item_table.setFlags(Qt.ItemIsSelectable
                                            | Qt.ItemIsEnabled)
                    dockwidget.QTableW_StraRS.setItem(m, n, item_table)
            if key == "On":
                for m in range(srs_table["row_count"]):
                    item_table = QTableWidgetItem()
                    item_table.setFlags(Qt.ItemIsUserCheckable
                                        | Qt.ItemIsEnabled)
                    item_table.setTextAlignment(Qt.AlignCenter
                                                | Qt.AlignVCenter)
                    if srs_table["On"][m]:
                        item_table.setCheckState(Qt.Checked)
                    else:
                        item_table.setCheckState(Qt.Unchecked)
                    dockwidget.QTableW_StraRS.setItem(m, n, item_table)

        # hidden row labels
        dockwidget.QTableW_StraRS.verticalHeader().setVisible(False)
        # add Header
        dockwidget.QTableW_StraRS.setHorizontalHeaderLabels(
            srs_table["header"])
        # adjust size of Table
        dockwidget.QTableW_StraRS.resizeColumnsToContents()
        dockwidget.QTableW_StraRS.resizeRowsToContents()
        # set label total samples
        total_num_samples = sum(
            [int(x) for x in mask(srs_table["num_samples"], srs_table["On"])])
        dockwidget.TotalNumSamples.setText(str(total_num_samples))
        # set maximum and reset the value in progress bar status
        dockwidget.widget_generate_StraRS.QPBar_GenerateSampling.setValue(0)
        dockwidget.widget_generate_StraRS.QPBar_GenerateSampling.setMaximum(
            total_num_samples)
Exemplo n.º 5
0
    def create_table(self):
        from AcATaMa.gui.acatama_dockwidget import AcATaMaDockWidget as AcATaMa

        header = ["Classification Name", "Color", "Thematic Class", ""]
        # clear table
        self.tableBtnsConfig.clear()
        # init table
        self.tableBtnsConfig.setRowCount(len(self.table_buttons))
        self.tableBtnsConfig.setColumnCount(4)
        # hidden row labels
        self.tableBtnsConfig.verticalHeader().setVisible(False)
        # add Header
        self.tableBtnsConfig.setHorizontalHeaderLabels(header)
        # insert items
        for n, h in enumerate(header):
            if h == "Classification Name":
                for m, (key, item) in enumerate(self.table_buttons.items()):
                    if m + 1 in self.buttons_config:
                        item_table = QTableWidgetItem(
                            self.buttons_config[m + 1]["name"])
                    else:
                        item_table = QTableWidgetItem(str(item))
                    item_table.setTextAlignment(Qt.AlignCenter
                                                | Qt.AlignVCenter)
                    item_table.setToolTip(
                        "Classification button ID: {}".format(key))
                    self.tableBtnsConfig.setItem(m, n, item_table)
            if h == "Color":
                for m, item in enumerate(self.table_buttons.values()):
                    item_table = QTableWidgetItem()
                    if m + 1 in self.buttons_config:
                        item_table.setBackground(
                            QColor(self.buttons_config[m + 1]["color"]))
                    item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
                    item_table.setTextAlignment(Qt.AlignCenter
                                                | Qt.AlignVCenter)
                    self.tableBtnsConfig.setItem(m, n, item_table)
            if h == "Thematic Class":
                for m, item in enumerate(self.table_buttons.values()):
                    if valid_file_selected_in(
                            AcATaMa.dockwidget.QCBox_ThematicRaster):
                        if m + 1 in self.buttons_config and self.buttons_config[
                                m + 1]["thematic_class"] is not None:
                            item_table = QTableWidgetItem(
                                self.buttons_config[m + 1]["thematic_class"])
                        else:
                            item_table = QTableWidgetItem(str(item))
                        item_table.setToolTip(
                            "Click to open the pixel value/color table of the thematic classes"
                        )
                    else:
                        item_table = QTableWidgetItem("none")
                        item_table.setFlags(Qt.ItemIsSelectable
                                            | Qt.ItemIsEnabled)
                        item_table.setForeground(QColor("lightGrey"))
                        item_table.setToolTip(
                            "No thematic layer, if you want enable the thematic classes,\n"
                            "select first a valid thematic layer in thematic tab"
                        )
                        item_h = QTableWidgetItem(h)
                        item_h.setForeground(QColor("lightGrey"))
                        self.tableBtnsConfig.setHorizontalHeaderItem(2, item_h)

                    item_table.setTextAlignment(Qt.AlignCenter
                                                | Qt.AlignVCenter)
                    self.tableBtnsConfig.setItem(m, n, item_table)
            if h == "":
                for m, item in enumerate(self.table_buttons.values()):
                    item_table = QTableWidgetItem()
                    path = ':/plugins/AcATaMa/icons/trash.svg'
                    icon = QIcon(path)
                    item_table.setIcon(icon)
                    item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
                    item_table.setTextAlignment(Qt.AlignCenter
                                                | Qt.AlignVCenter)
                    item_table.setToolTip("Clean this row")
                    self.tableBtnsConfig.setItem(m, n, item_table)

        # set the minimum width to 0 for headers
        self.tableBtnsConfig.horizontalHeader().setMinimumSectionSize(0)
        # adjust size of Table
        self.tableBtnsConfig.resizeColumnsToContents()
        self.tableBtnsConfig.resizeRowsToContents()
        # adjust the dialog based on table content
        dialog_width = self.tableBtnsConfig.horizontalHeader().length() + 50
        self.resize(dialog_width, self.height())