class PodgladDanych(QDialog):
    def __init__(self, model):
        QDialog.__init__(self)
        self.resize(QSize(1081, 750))
        self.model = model
        self.tableViewPodgladDanych = QTableView(self)
        self.tableViewPodgladDanych.resize(QSize(1070, 740))
        self.tableViewPodgladDanych.setModel(model)
Exemple #2
0
 def showdf(self, df):
     model = PdQtClass.pandasModel(df)
     view = QTableView()
     view.setModel(model)
     view.resize(800, 600)
     self.w = QTableView()
     self.w.setModel(model)
     self.w.resize(480, 320)
     self.w.show()
class SQLite(QSqlDatabase):
    """
    Класс для инициализации и открытия базы данных каталога, полученный из Slot'а (openFile)
    """
    def __init__(self, path=None):
        """
        Инициализация экземпляра класса
        :param path: путь до каталога, полученный изиз Slot'а (openFile)
        """
        super().__init__()
        self.path = path
        self.width = 0
        self.heigh = 0
        self.db = QSqlDatabase.addDatabase('QSQLITE')
        self.db.setDatabaseName(self.path)
        self.db.open()
        self.window = QWidget()
        self.window.setWindowTitle("Каталог книг")
        self.conn = sqlite3.connect(self.path)
        cursor = self.conn.cursor()
        sql = f'select * from sqlite_master where type = "table"'  # получение имени таблицы(первая в списке), к которой будет
        # осуществлено подключение
        cursor.execute(sql)
        self.search_result = cursor.fetchall()[0][1]
        self.model = QSqlTableModel(parent=self.window, db=self.db)
        self.model.setTable(self.search_result)
        self.db_record = QSqlRecord(self.db.record(self.search_result))
        self.tableView = QTableView()

    def on(self):
        """
        Метод для подключения и отображения подключенного каталога
        :return: виджет self.window
        """
        self.model.setEditStrategy(QSqlTableModel.OnManualSubmit)
        self.model.select()
        self.model.setHeaderData(-1, Qt.Horizontal,
                                 self.db_record.fieldName(0))
        vbox = QVBoxLayout()
        self.tableView.setModel(self.model)
        self.tableView.resizeColumnsToContents()
        self.tableView.resizeRowsToContents()
        for i in range(self.model.columnCount() + 2):
            self.width += self.tableView.columnWidth(i)
        for j in range(self.model.rowCount() + 1):
            self.heigh += self.tableView.rowHeight(j)
        self.tableView.resize(self.width + 50, self.heigh + 50)
        vbox.addWidget(self.tableView)
        self.window.setLayout(vbox)
        self.window.resize(self.tableView.width() + 30,
                           self.tableView.height() + 120)
        return self.window
Exemple #4
0
class MyMainWindow(QMainWindow, Ui_PySide2_Chroma_Eload_GUI.Ui_MainWindow):
    def __init__(self, parent=None):
        super(MyMainWindow, self).__init__(parent)
        self.setupUi(self)
        self.commandLinkButton.clicked.connect(self.pushButton_Click)
        self.pushButton.clicked.connect(self.detectGPIB)
        self.pushButton_2.clicked.connect(self.openDf_csv)
        self.pushButton_3.clicked.connect(self.reflash_filename)

        ##to do , select checkbox then goto next step
        ##self.checkBox_1.checked.connect(self.setNextOn)

        # set window title
        self.setWindowTitle("PyEfficiency 2022.03.09")
        self.setFixedSize(720, 800)
        self.checkBox.setChecked(False)

        #set DC source On
        self.pushButton_4.clicked.connect(self.dcsourceOn)
        #set DC source Off
        self.pushButton_5.clicked.connect(self.dcsourceOff)

        self.show()
        self.time = str(datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
        self.filename = self.time + ".csv"
        #set defalut file name
        self.init_save_filename = "PyEff_"
        self.lineEdit.setText(self.init_save_filename)
        self.df = pd.DataFrame()

        #set "open reuslt" button isn't work in GUI init.
        self.pushButton_2.setEnabled(False)

        #set comboBox value
        self.comboBox.setCurrentText("7")
        #self.comboBox.setEnabled(True)
        self.comboBox_2.setCurrentText("9")
        #self.comboBox_2.setEnabled(True)
        self.comboBox_3.setCurrentText("5")

    def openDf_csv(self):
        self.filename = self.lineEdit.text()
        self.df.to_csv(self.filename)
        os.system("start excel.exe %s" % self.filename)

    def pushButton_Click(self):
        self.reflash_filename()
        if (self.checkBox_1.isChecked() or self.checkBox_3.isChecked()
                or self.checkBox_5.isChecked() or self.checkBox_7.isChecked()
                or self.checkBox_9.isChecked()
                or self.checkBox_51.isChecked()) == 0:
            QMessageBox.about(self, "Warning",
                              "please checked Eload channel in the GUI")
        else:
            loadlist = gpib.ComboEload()
            Iout_max = int(self.lineEdit_2.text())
            Iout_step = int(self.lineEdit_3.text())
            Delay = int(self.lineEdit_4.text())
            gpibaddr1 = int(self.comboBox.currentText())
            gpibaddr2 = int(self.comboBox_2.currentText())
            if self.checkBox_1.isChecked():
                load1 = gpib.ChromaEload(gpibaddr1, 1,
                                         int(self.lineEdit_L1.text()), 0)
                loadlist.addEload(load1)

            if self.checkBox_3.isChecked():
                load3 = gpib.ChromaEload(gpibaddr1, 3,
                                         int(self.lineEdit_L3.text()), 0)
                loadlist.addEload(load3)

            if self.checkBox_5.isChecked():
                load5 = gpib.ChromaEload(gpibaddr1, 5,
                                         int(self.lineEdit_L5.text()), 0)
                loadlist.addEload(load5)

            if self.checkBox_7.isChecked():
                load7 = gpib.ChromaEload(gpibaddr1, 7,
                                         int(self.lineEdit_L7.text()), 0)
                loadlist.addEload(load7)

            if self.checkBox_9.isChecked():
                load9 = gpib.ChromaEload(gpibaddr1, 9,
                                         int(self.lineEdit_L9.text()), 0)
                loadlist.addEload(load9)

            if self.checkBox_51.isChecked():
                load51 = gpib.ChromaEload(gpibaddr2, 1,
                                          int(self.lineEdit_L51.text()), 0)
                loadlist.addEload(load51)

            #df=measure.measureEfficiency(loadlist,Iout_max,Iout_step,Delay)
            if self.checkBox.isChecked():
                df = measure.measureEfficiency(loadlist, Iout_max, Iout_step,
                                               Delay, 1)
            else:
                df = measure.measureEfficiency(loadlist, Iout_max, Iout_step,
                                               Delay, 0)

            #self.textBrowser.setText("Efficiency finish")

            self.showdf(df)
            self.df = df
            self.pushButton_2.setEnabled(True)
            self.df.to_csv(self.lineEdit.text())

    def detectGPIB(self):
        df = gpib.scanGPIB()
        self.showdf(df)

    def showdf(self, df):
        model = PdQtClass.pandasModel(df)
        view = QTableView()
        view.setModel(model)
        view.resize(800, 600)
        self.w = QTableView()
        self.w.setModel(model)
        self.w.resize(480, 320)
        self.w.show()

    # for test button
    def pushbutton3(self):

        self.pushButton_2.setEnabled(True)
        self.filename = self.lineEdit.text()
        print(self.time)
        print(self.filename)
        self.reflash_filename()
        self.pushButton_4.setStyleSheet('background-color: Red')

    def reflash_filename(self):
        self.time = str(datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
        self.filename = self.init_save_filename
        self.lineEdit.setText(self.filename + self.lineEdit_5.text() +
                              "Vin_Imax" + self.lineEdit_2.text() + "A_" +
                              self.time + ".csv")

    #set DC source
    def dcsourceOn(self):
        voltage = float(self.lineEdit_5.text())
        current = int(self.lineEdit_6.text())
        gpibaddr = int(self.comboBox_3.currentText())
        self.push_msg_to_GUI(
            f'set DC source to {voltage}V, {current}A and turn on')
        dcsource = gpib.AgilentDCsource(gpibaddr, voltage, current)
        dcsource.On()
        self.pushButton_4.setStyleSheet('background-color: Red')
        None

    def dcsourceOff(self):
        voltage = float(self.lineEdit_5.text())
        current = int(self.lineEdit_6.text())
        gpibaddr = int(self.comboBox_3.currentText())
        dcsource = gpib.AgilentDCsource(gpibaddr, voltage, current)
        dcsource.Off()
        self.push_msg_to_GUI("Turn off DC source")
        self.pushButton_4.setStyleSheet('background-color: None')

    ## to do , select checkbox then goto next step
    def setNextOn(self):
        None

    def push_msg_to_GUI(self, msg=""):
        if True:
            self.textEdit.append(str(msg))
            self.textEdit.append("")
        else:
            pass
Exemple #5
0
class info_window(QDialog):
    def __init__(self, info, info_type='test'):
        super().__init__()
        self.second_attrib = None
        # self.setMinimumSize(280,600)
        if info_type == 'test':
            self.label = QLabel(info, self)
            self.setWindowTitle('子窗口')
        else:
            # print(info)
            # print(type(info))
            self.setWindowTitle(info_dic[info_type])
            for k, v in info.items():
                self.second_attrib = v
                break
            if type(self.second_attrib) == dict:
                self.model = QStandardItemModel(len(info),
                                                len(self.second_attrib))
                self.model.setHorizontalHeaderLabels(
                    armydef_dic[key] for key in self.second_attrib.keys())
                self.model.setVerticalHeaderLabels(armydef_dic[key]
                                                   for key in info.keys())
                for row, row_info in zip(range(len(info)), info.values()):
                    for column, column_info in zip(
                            range(len(self.second_attrib)), row_info.values()):
                        item = QStandardItem(column_info)
                        self.model.setItem(row, column, item)
                # 实例化表格视图,设置模型为自定义的模型
                self.tableView = QTableView(self)
                self.tableView.resize(400, 600)
                self.tableView.setModel(self.model)
                # #todo 优化1 表格填满窗口
                # #水平方向标签拓展剩下的窗口部分,填满表格
                # 水平方向标签拓展剩下的窗口部分,填满表格
                self.tableView.horizontalHeader().setStretchLastSection(True)
                # 水平方向,表格大小拓展到适当的尺寸
                self.tableView.horizontalHeader().setSectionResizeMode(
                    QHeaderView.Stretch)
                #
                # #TODO 优化3 删除当前选中的数据
                # indexs=self.tableView.selectionModel().selection().indexes()
                # print(indexs)
                # if len(indexs)>0:
                #     index=indexs[0]
                #     self.model.removeRows(index.row(),1)
            else:
                self.model = QStandardItemModel(len(info), 1)
                self.model.setVerticalHeaderLabels(commanderdef_dic[key]
                                                   for key in info.keys())
                # exit(0)
                for row, row_info in zip(range(len(info)), info.values()):
                    item = QStandardItem(row_info)
                    self.model.setItem(row, item)
                # 实例化表格视图,设置模型为自定义的模型
                self.tableView = QTableView(self)
                self.tableView.resize(400, 600)
                self.tableView.setModel(self.model)
                # #todo 优化1 表格填满窗口
                # #水平方向标签拓展剩下的窗口部分,填满表格
                # 水平方向标签拓展剩下的窗口部分,填满表格
                self.tableView.horizontalHeader().setStretchLastSection(True)
                # 水平方向,表格大小拓展到适当的尺寸
                self.tableView.horizontalHeader().setSectionResizeMode(
                    QHeaderView.Stretch)
Exemple #6
0
class DLPSettingsGUI(QWidget):

    def __init__(self, dlp_controller=None, dlp_slicer=None, parent=None):
        QWidget.__init__(self, parent)
        self.parent = parent
        self.dlp_controller = dlp_controller
        self.dlp_slicer = dlp_slicer
        self.dlp_color_calibrator = DLPColorCalibrator()
        self.dlp_color_calibrator.analysis_completed_signal.connect(self.update_charts)
        self.__printer_parameters_list = {}
        self.__slicer_parameters_list = {}
        self.data_fit_chart_view = None
        self.data_fit_chart = None
        self.main_layout = QHBoxLayout()
        self.__init_table_widget__()
        self.__init_color_calibration_widget()
        self.__default_parameters_widget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.MinimumExpanding)
        self.main_layout.addWidget(self.__default_parameters_widget, stretch=1)
        self.main_layout.addWidget(self.__color_calibration_widget, stretch=2)
        self.setLayout(self.main_layout)
        self.main_layout.update()

    def __init_color_calibration_widget(self, parent=None):
        self.__color_calibration_widget = QGroupBox("Color Correction Options", parent)
        self.__color_calibration_widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
        color_calibration_layout = QVBoxLayout(self.__color_calibration_widget)

        chart_widget = QWidget(self.__color_calibration_widget)
        chart_layout = QGridLayout(chart_widget)
        self.data_fit_chart = QtCharts.QChart()
        self.data_fit_chart_view = QtCharts.QChartView(self.data_fit_chart)
        self.axis_x = QtCharts.QValueAxis()
        self.axis_x.setTitleText("Pixel Intensity")
        self.axis_x.setRange(0, 1)
        self.data_fit_chart.addAxis(self.axis_x, Qt.AlignBottom)
        self.axis_y = QtCharts.QValueAxis()
        self.axis_y.setTitleText("Voxel Height (\u03BCm)")
        self.axis_y.setRange(0, 10)
        self.data_fit_chart.addAxis(self.axis_y, Qt.AlignLeft)
        chart_layout.addWidget(self.data_fit_chart_view, 0, 0, 1, 4)
        chart_widget.setLayout(chart_layout)

        buttons_widget = QWidget(self.__color_calibration_widget)
        buttons_layout = QHBoxLayout(buttons_widget)
        analyze_data_button = QPushButton("Analyze Data")
        analyze_data_button.clicked.connect(self.analyze_images)
        self.parameters_estimation_label = QLabel(f'Estimated parameters: \u03B1 = {self.dlp_color_calibrator.optimized_parameters[0]:.3f}, \u03B2 = {self.dlp_color_calibrator.optimized_parameters[1]:.3f}, \u03B3 =  {self.dlp_color_calibrator.optimized_parameters[2]:.3f}',
                                buttons_widget)
        buttons_layout.addWidget(analyze_data_button)
        buttons_layout.addWidget(self.parameters_estimation_label)
        buttons_widget.setLayout(buttons_layout)
        color_calibration_layout.addWidget(chart_widget)
        color_calibration_layout.addWidget(buttons_widget)
        self.__color_calibration_widget.setLayout(color_calibration_layout)

    @Slot()
    def analyze_images(self):
        file_names = QFileDialog.getOpenFileNames(caption='Select data', dir='../measured_data/grayscale_measured_data',
                                                  filter="Image Files (*.asc)")
        self.dlp_color_calibrator.analyze_data_files(file_names[0])

    @Slot()
    def update_charts(self):
        self.data_fit_chart = QtCharts.QChart()
        self.data_fit_chart.setAnimationOptions(QtCharts.QChart.AllAnimations)
        self.add_series(self.data_fit_chart, "Measured Data", self.dlp_color_calibrator.input_values, self.dlp_color_calibrator.average_data)
        self.add_series(self.data_fit_chart, "Fitted Curve", self.dlp_color_calibrator.input_values,
                        self.dlp_color_calibrator.fitted_curve)
        self.add_series(self.data_fit_chart, "Predicted Result", self.dlp_color_calibrator.input_values,
                        self.dlp_color_calibrator.corrected_output_values)
        series = self.data_fit_chart.series()
        self.data_fit_chart.addAxis(self.axis_x, Qt.AlignBottom)
        self.axis_y.setRange(0, self.dlp_color_calibrator.measured_thickness)
        self.data_fit_chart.addAxis(self.axis_y, Qt.AlignLeft)
        for s in series:
            s.attachAxis(self.axis_x)
            s.attachAxis(self.axis_y)

        self.data_fit_chart_view.setRenderHint(QPainter.Antialiasing)
        self.data_fit_chart_view.setChart(self.data_fit_chart)

        self.parameters_estimation_label.setText(f'Estimated parameters: \u03B1 = {self.dlp_color_calibrator.optimized_parameters[0]:.3f}, \u03B2 = {self.dlp_color_calibrator.optimized_parameters[1]:.3f}, \u03B3 =  {self.dlp_color_calibrator.optimized_parameters[2]:.3f}')

    def add_series(self, chart, title, x, y):
        series = QtCharts.QLineSeries()
        series.setName(title)
        for idx, elem in enumerate(x):
            series.append(x[idx], y[idx])
        chart.addSeries(series)

    def __init_table_widget__(self, parent=None):
        self.__default_parameters_widget = QGroupBox("Default Parameters", parent)
        self.printer_parameters_list = self.dlp_controller.get_default_parameters()
        self.table_view = QTableView()
        self.table_model = self.MyTableModel(parent=self.__default_parameters_widget, data_list=self.printer_parameters_list)
        self.table_view.setModel(self.table_model)
        self.table_view.horizontalHeader().setVisible(False)
        self.table_view.verticalHeader().setVisible(False)
        self.table_view.horizontalHeader().setStretchLastSection(False)
        # self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
        self.table_view.resizeColumnsToContents()
        self.table_view.update()
        # self.table_view.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
        # self.table_view.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents)
        apply_button = QPushButton("Apply Changes", self.__default_parameters_widget)
        apply_button.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
        apply_button.clicked.connect(self.dlp_controller.save_default_parameters)
        default_parameters_layout = QVBoxLayout(self.__default_parameters_widget)
        default_parameters_layout.addWidget(self.table_view)
        default_parameters_layout.addWidget(apply_button)
        self.__default_parameters_widget.setLayout(default_parameters_layout)
        self.__default_parameters_widget.updateGeometry()
        # default_parameters_layout.update()
        # QGuiApplication.processEvents()

    @Slot()
    def __adjust_table_size__(self):
        self.table_view.resizeColumnToContents(0)
        self.table_view.resizeColumnToContents(1)
        rect = self.table_view.geometry()
        rect.setWidth(1 + self.table_view.verticalHeader().width() + self.table_view.columnWidth(0) +
                      self.table_view.columnWidth(1) + self.table_view.verticalScrollBar().width())
        self.table_view.setGeometry(rect)
        self.table_view.resize(rect.width(), rect.height())

    class MyTableModel(QAbstractTableModel):
        def __init__(self, parent, data_list, *args):
            QAbstractTableModel.__init__(self, parent, *args)
            self.parent = parent
            self.data_list = data_list

        def rowCount(self, parent):
            return len(self.data_list)

        def columnCount(self, parent):
            return 2

        def data(self, index, role):
            if not index.isValid():
                return None
            elif role != Qt.DisplayRole:
                return None
            return list(self.data_list.items())[index.row()][index.column()]

        def setData(self, index, value, role):
            if role == Qt.EditRole:
                if not index.isValid():
                    return False
                elif index.column() == 0:
                    return False
                else:
                    key = list(self.data_list.items())[index.row()][0]
                    old_value = list(self.data_list.items())[index.row()][1]
                    try:
                        if isinstance(old_value, float):
                            self.data_list[key] = float(value)
                        elif isinstance(old_value, bool):
                            if value == "True" or value == "true":
                                self.data_list[key] = True
                            else:
                                self.data_list[key] = False
                        elif isinstance(old_value, str):
                            if index.row() == 0:
                                if not (value.upper() == "TOP-DOWN" or value.upper() == "BOTTOM-UP"):
                                    return False
                            self.data_list[key] = str(value).upper()
                    except ValueError:
                        return False
                    self.dataChanged.emit(index, index)
                    return True
            else:
                return False

        def flags(self, index):
            if not index.isValid() or index.column() == 0:
                return Qt.ItemIsEnabled
            return Qt.ItemFlags(QAbstractTableModel.flags(self, index) |
                                Qt.ItemIsEditable)
Exemple #7
0
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
##
## $QT_END_LICENSE$
##
#############################################################################

import sys

from PySide2.QtCore import Qt
from PySide2.QtSql import QSqlQueryModel
from PySide2.QtWidgets import QTableView, QApplication

import createdb
from bookdelegate import BookDelegate

if __name__ == "__main__":
    app = QApplication()
    createdb.init_db()

    model = QSqlQueryModel()
    model.setQuery("select title, author, genre, year, rating from books")

    table = QTableView()
    table.setModel(model)
    table.setItemDelegate(BookDelegate())
    table.resize(800, 600)
    table.show()

    sys.exit(app.exec_())
Exemple #8
0
## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
## LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
##
## $QT_END_LICENSE$
##
#############################################################################

import sys

from PySide2.QtSql import QSqlQueryModel
from PySide2.QtWidgets import QTableView, QApplication

import createdb

if __name__ == "__main__":
    app = QApplication()
    createdb.init_db()

    model = QSqlQueryModel()
    model.setQuery("select * from books")

    table_view = QTableView()
    table_view.setModel(model)
    table_view.resize(800, 600)
    table_view.show()
    sys.exit(app.exec_())
Exemple #9
0

if __name__ == '__main__':
    import sys
    import numpy as np
    from PySide2.QtWidgets import QApplication, QTableView, QVBoxLayout

    # User specifies grains.out file
    if (len(sys.argv) < 2):
        print()
        print('Load grains.out file and display as table')
        print('Usage: python fit_grains_resuls_model.py  <path-to-grains.out>')
        print()
        sys.exit(-1)

    # print(sys.argv)
    app = QApplication(sys.argv)

    data = np.loadtxt(sys.argv[1])
    # print(data)

    model = FitGrainsResultsModel(data)
    view = QTableView()
    view.verticalHeader().hide()
    view.setModel(model)
    view.resizeColumnToContents(0)
    view.resize(960, 320)

    view.show()
    app.exec_()
    def __init__(self, data):
        QAbstractTableModel.__init__(self)
        self._data = data

    def rowCount(self, parent=None):
        return self._data.shape[0]

    def columnCount(self, parnet=None):
        return self._data.shape[1]

    def data(self, index, role=Qt.DisplayRole):
        if index.isValid():
            if role == Qt.DisplayRole:
                return str(self._data.iloc[index.row(), index.column()])
        return None

    def headerData(self, col, orientation, role):
        if orientation == Qt.Horizontal and role == Qt.DisplayRole:
            return self._data.columns[col]
        return None

if __name__ == '__main__':
    df=pd.read_csv("2022-02-21_13-32-36.csv")
    app = QApplication(sys.argv)
    model = pandasModel(df)
    view = QTableView()
    view.setModel(model)
    view.resize(800, 600)
    view.show()
    sys.exit(app.exec_())