示例#1
0
    def _setup(self):
        # setup drag an drop
        self.setDragDropMode(self.InternalMove)
        self.setAcceptDrops(True)
        self.setDropIndicatorShown(True)
        self.setDragDropOverwriteMode(True)

        self._tree_model = TreeModel(self._api, self._root, parent=self)
        self._tree_proxy = makeQSortFilterProxyModel(self)
        self._tree_proxy.setSourceModel(self._tree_model)
        self.setSortingEnabled(True)
        self.sortByColumn(0, QtCore.Qt.AscendingOrder)
        self._tree_proxy.setDynamicSortFilter(True)

        self._tree_proxy.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self._tree_proxy.setSortRole(TreeModel.sortRole)
        self._tree_proxy.setFilterRole(TreeModel.filterRole)

        self.setModel(self._tree_proxy)
        self.setColumnWidth(0, 175)

        header = self.header()
        header.setStretchLastSection(False)
        setHeaderViewResizeMode(header, QtWidgets.QHeaderView.Stretch, 0)
        self.setAnimated(True)
示例#2
0
文件: ivi.py 项目: uweschmitt/ivi
class IdentViewer(MainWindow):

    def __init__(self, reader):
        super(IdentViewer, self).__init__()
        # fix mac
        if sys.platform == "darwin":
            self.menubar.setNativeMenuBar(False)
        self.reader = reader
        self.setup()
        self.connect_signals()

    def setup(self):
        self.preferences = default_preferences()

        self.tree_model = TreeModel(self.reader)
        self.tree_model.set_preferences(self.preferences)
        self.tree_view.setModel(self.tree_model)
        self.setup_tree_view_size()

    def setup_tree_view_size(self):
        self.tree_view.setMinimumWidth(400)
        self.tree_view.setColumnWidth(0, 200)
        self.tree_view.resizeColumnToContents(1)
        self.tree_view.resizeColumnToContents(2)
        self.tree_view.resizeColumnToContents(3)

    def connect_signals(self):
        self.tree_view.clicked.connect(self.tree_model.select)

        self.tree_model.spectrumSelected.connect(self.spectrum_plotter.plot_spectrum)

        self.tree_model.featureSelected.connect(self.peakmap_plotter.plot_feature)
        self.tree_model.featureSelected.connect(self.chromatogram_plotter.plot_chromatograms_from_feature)

        self.tree_model.massTraceSelected.connect(self.peakmap_plotter.plot_mass_trace)
        self.tree_model.massTraceSelected.connect(self.chromatogram_plotter.plot_chromatogram_from_masstrace)

        self.tree_model.ms1HitChanged.connect(self.peakmap_plotter.clear)
        self.tree_model.ms1HitChanged.connect(self.chromatogram_plotter.clear)

        self.tree_model.ms2HitChanged.connect(self.spectrum_plotter.clear)

        self.tree_model.newHitRt.connect(self.chromatogram_plotter.set_rt_marker)

        self.chromatogram_plotter.rtCursorMoved.connect(self.peakmap_plotter.move_marker_to_rt)
        self.peakmap_plotter.cursorMoved.connect(self.chromatogram_plotter.move_marker)

    def row_chosen(self, i):
        self.tree_view.selectRow(i)

    def edit_preferences(self):
        dlg = PreferencesDialog(self.preferences, parent=self)
        closed_as = dlg.exec_()
        if closed_as == QtGui.QDialog.Accepted:
            self.preferences = dlg.get_preferences()
            self.tree_model.set_preferences(self.preferences)

    def open_file(self):
        pass
示例#3
0
文件: ivi.py 项目: uweschmitt/ivi
    def setup(self):
        self.preferences = default_preferences()

        self.tree_model = TreeModel(self.reader)
        self.tree_model.set_preferences(self.preferences)
        self.tree_view.setModel(self.tree_model)
        self.setup_tree_view_size()
示例#4
0
文件: tests.py 项目: soarlab/paf
def test_TreeModel():
    # typical model test
    exponent = 8
    mantissa = 24
    file = "tests/my_expression.txt"
    f = open(file, "r")
    file_name = (ntpath.basename(file).split(".")[0]).lower()  # (file.split(".")[0]).lower()
    text = f.read()
    text = text[:-1]
    f.close()
    myYacc = FPRyacc(text, False)
    start_time = time()
    T = TreeModel(myYacc, mantissa, exponent, [40, 10], 100, 250000, error_model="high_precision")
    end_time = time()
    print("Exe time --- %s seconds ---" % (end_time - start_time))
    plt.close("all")
    matplotlib.rcParams.update({'font.size': 11})
    fig, a = plt.subplots(2, 2)
    dist = T.tree.root_value[0].distribution
    t0 = dist.range_()[0]
    tf = dist.range_()[1]
    x = np.linspace(t0, tf, 100)
    a[0][0].plot(x, dist.pdf(x))
    a[0][0].set_title("Unquantized operations")
    dist = T.tree.root_value[1].distribution
    t0 = dist.range_()[0]
    tf = dist.range_()[1]
    x = np.linspace(t0, tf, 100)
    a[0][1].plot(x, dist.pdf(x))
    a[0][1].set_title("Last error")
    dist = T.tree.root_value[2].distribution
    t0 = dist.range_()[0]
    tf = dist.range_()[1]
    x = np.linspace(t0, tf, 100)
    a[1][0].plot(x, dist.pdf(x))
    a[1][0].set_title("Quantized operations")
    plt.show()
示例#5
0
    "Next coin rel y",
    "Crates around next coin",
    "Bomb possible",
    "Sum all crates",
    "Agent pos rel to wall",
    "Free space down",
    "Free space right",
    "Free space up",
    "Free space left",
    "Survivable spaces down",
    "Survivable spaces right",
    "Survivable spaces up",
    "Survivable spaces left",
    "Survivable spaces wait"
]

labels = ['UP', 'DOWN', 'LEFT', 'RIGHT', 'BOMB', 'WAIT']

model = TreeModel(1000, (21, ), (6, ), 1)
model.load('agent_code/minimal_tree_1/actor.p')
X = np.load('agent_code/minimal_tree_1/actor_X.npy')
y = np.load('agent_code/minimal_tree_1/actor_y.npy')[:, 0]

plt.figure(figsize=(25, 20))
tree.plot_tree(model.model,
               feature_names=cols,
               class_names=y,
               max_depth=10,
               fontsize=4)
plt.show()
#print(tree.export_text(model.model)[:10000])
示例#6
0
文件: main.py 项目: soarlab/paf
def process_file(file, mantissa, exp, range_my_dict, abs_my_dict):
    try:
        print("\n\n\n\n" + file + "\n\n\n\n\n")
        f = open(file, "r")
        file_name = (ntpath.basename(file).split(".")[0]
                     ).lower()  # (file.split(".")[0]).lower()
        text = f.read()
        text = text[:-1]
        f.close()
        myYacc = FPRyacc(text, False)
        start_time = time.time()
        T = TreeModel(
            myYacc, mantissa, exp, [40, 10], 50,
            250000)  #, error_model="typical", dependent_mode="p-box")
        end_time = time.time()
        print("Exe time --- %s seconds ---" % (end_time - start_time))
        finalTime = end_time - start_time

        if os.path.exists(output_path + file_name):
            shutil.rmtree(output_path + file_name)
        os.makedirs(output_path + file_name)

        #loadedSamples, values_samples, abs_err_samples, rel_err_samples = T.generate_error_samples(5, file_name)
        loadedGolden, values_golden, abs_err_golden, rel_err_golden, err_golden = T.generate_error_samples(
            golden_model_time, file_name, golden=True)

        with open(
                output_path + file_name + "/" + file_name +
                "_constraints_log.out", "w+") as log:
            print(T.logging_constraints, file=log)

        f = open(
            output_path + file_name + "/" + file_name + "_CDF_summary.out",
            "w+")
        f.write("Execution Time:" + str(finalTime) + "s \n\n")
        plot_range_analysis_CDF(T, loadedGolden, values_golden, f, file_name,
                                range_my_dict.get(file_name))
        plot_abs_error_analysis_CDF(T, loadedGolden, abs_err_golden, f,
                                    file_name, abs_my_dict.get(file_name),
                                    rel_my_dict.get(file_name))
        #plot_error_analysis_CDF(T, loadedGolden, err_golden, f, file_name, abs_my_dict.get(file_name), rel_my_dict.get(file_name))
        #plot_abs_error_analysis_CDF(T.relative_err_distr, loadedGolden, rel_err_samples, rel_err_golden, f, file_name, abs_my_dict.get(file_name), rel_my_dict.get(file_name))
        f.flush()
        f.close()

        f = open(
            output_path + file_name + "/" + file_name + "_PDF_summary.out",
            "w+")
        f.write("Execution Time:" + str(finalTime) + "s \n\n")
        #plot_range_analysis_PDF(T.final_quantized_distr, loadedGolden, values_golden, f, file_name, range_my_dict.get(file_name))
        #plot_error_analysis_PDF(T.abs_err_distr, loadedGolden, abs_err_samples, abs_err_golden, f, file_name, abs_my_dict.get(file_name), rel_my_dict.get(file_name))
        f.flush()
        f.close()

    except Exception as e:
        logging.error(traceback.format_exc())

    finally:
        del values_golden, abs_err_golden, rel_err_golden
        gc.collect()
        matplotlib.pyplot.close("all")
示例#7
0
class VrayPropTreeView(QtWidgets.QTreeView):
    on_parent_changed = QtCore.Signal(QtCore.QModelIndex)

    def __init__(self, api, parent=None):
        super(VrayPropTreeView, self).__init__(parent=parent)

        self._tree_model = None
        self._tree_proxy = None
        self._api = api
        self._root = Root()
        self._setup()
        self._connect_signals()

    def get_proxy(self):
        return self._tree_proxy

    def get_model(self):
        return self._tree_model

    def _setup(self):
        # setup drag an drop
        self.setDragDropMode(self.InternalMove)
        self.setAcceptDrops(True)
        self.setDropIndicatorShown(True)
        self.setDragDropOverwriteMode(True)

        self._tree_model = TreeModel(self._api, self._root, parent=self)
        self._tree_proxy = makeQSortFilterProxyModel(self)
        self._tree_proxy.setSourceModel(self._tree_model)
        self.setSortingEnabled(True)
        self.sortByColumn(0, QtCore.Qt.AscendingOrder)
        self._tree_proxy.setDynamicSortFilter(True)

        self._tree_proxy.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
        self._tree_proxy.setSortRole(TreeModel.sortRole)
        self._tree_proxy.setFilterRole(TreeModel.filterRole)

        self.setModel(self._tree_proxy)
        self.setColumnWidth(0, 175)

        header = self.header()
        header.setStretchLastSection(False)
        setHeaderViewResizeMode(header, QtWidgets.QHeaderView.Stretch, 0)
        self.setAnimated(True)

    def _gen_new_dir(self):
        dir = self._api.create_directory()
        self._tree_model.insertNode(dir)

    def _rcmenu(self, x):
        menu = QtWidgets.QMenu(self)
        new_dir = QtWidgets.QAction(self)
        new_dir.setText('New Directory')
        new_dir.triggered.connect(self._gen_new_dir)
        menu.addAction(new_dir)
        menu.exec_(self.mapToGlobal(x))

    def _connect_signals(self):
        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(lambda x: self._rcmenu(x))

    def _is_valid_drop(self, drag_node, drop_node):
        if not drop_node and drag_node.parent == self._root:
            return False
        if drag_node == drop_node:
            return False
        if not drop_node:
            return True
        if drag_node.parent == drop_node:
            return False
        if drop_node.is_descendant_of(drag_node):
            return False
        return True

    def _get_importer_at_pos(self, pos):
        index = self._tree_proxy.mapToSource(self.indexAt(pos))
        return self._tree_model.data(index, self._tree_model.itemRole)

    def get_selected_impoter(self):
        selMod = self.selectionModel()
        indx = selMod.selectedIndexes()[0]
        indx = self._tree_proxy.mapToSource(indx)
        return self._tree_model.data(indx, self._tree_model.itemRole)

    def dragMoveEvent(self, event):
        drag_node = self.get_selected_impoter()
        drop_node = self._get_importer_at_pos(event.pos())

        if not self._is_valid_drop(drag_node, drop_node):
            event.ignore()
            return

        event.accept()

    def dropEvent(self, event):
        self._updateSel = False
        drop_node = self._get_importer_at_pos(event.pos())
        drag_node = self.get_selected_impoter()

        if not self._is_valid_drop(drag_node, drop_node):
            event.ignore()
            return

        new_index = self._tree_model.parentNode(drag_node, drop_node)
        self.on_parent_changed.emit(new_index)