Example #1
0
    def save_project(self, project: Project):
        project_data = project.get_project_data()
        error_message = "保存项目: " + project.project_full_path() + "失败!\n"
        file = None
        try:
            file = QFile(project.project_full_path())
            if not file.open(QIODevice.WriteOnly):
                raise (IOError, str(file.errorString()))

            stream = Stream(file)
            stream.writeInt32(Stream.MAGIC_NUMBER)
            stream.writeInt32(Stream.FILE_VERSION)
            stream.setVersion(QDataStream.Qt_5_1)

            stream << project_data[0]
            stream << project_data[1]
            stream << project_data[2]
            stream << project_data[3]
            for data in project_data[4:]:
                for d in data:
                    stream << d

        except IOError as e:
            print(type(e))
            return False, error_message + str(e)
        except Exception as e:
            print("****************************: ", e)
        finally:
            if file:
                file.close()
            return True, error_message
Example #2
0
    def get_project_from_project_data(self, project_data) -> Project:
        project = Project(file_name=project_data[0],
                          project_name=project_data[1],
                          image_path=project_data[2],
                          person_name=project_data[3])

        for item_data in project_data[4:]:
            item = MarkItem.from_list_mark_data_to_item(item_data)
            project.add_mark_item(item)
        return project
Example #3
0
    def export_result(self, path, project: Project, size: QSize, parent):
        tif_result = QImage(size, QImage.Format_RGB32)
        mark_items = project.get_mark_items()

        painter = QPainter()
        painter.begin(tif_result)
        for mark_item in mark_items:
            painter.fillPath(mark_item.get_outline(), mark_item.color)
        painter.end()
        tif_result_array = qimage2numpy(tif_result)
        Image.fromarray(tif_result_array).save(path)
Example #4
0
def count_project_data_perimeter(project: Project):
    """"""
    perimeter = []
    for mark_item in project.get_mark_items():
        mark_item_area = count_mark_item_perimeter(mark_item)
        had_type = [_type[0] for _type in perimeter]

        if mark_item_area[0] in had_type:
            index = had_type.index(mark_item_area[0])
            data = perimeter[index][1] + mark_item_area[1]
            perimeter[index][1] = data
        else:
            perimeter.append(mark_item_area)
    return tuple(perimeter)
Example #5
0
def count_project_data_area(project: Project):
    """"""
    area = []
    for mark_item in project.get_mark_items():

        mark_item_area = count_mark_item_area(mark_item)
        had_type = [_type[0] for _type in area]

        if mark_item_area[0] in had_type:
            index = had_type.index(mark_item_area[0])
            data = area[index][1] + mark_item_area[1]
            area[index][1] = data
        else:
            area.append(mark_item_area)
    return tuple(area)
Example #6
0
    def __init__(self,
                 gadget,
                 toolbar_gadget,
                 file_name=None,
                 project_name=None,
                 image_path=None,
                 person_name=None,
                 parent=None,
                 eraser_size=3,
                 eraser_option=SelectionOptionToolBar.Subtract):
        super(Document, self).__init__(parent)
        ProjectDocument.__init__(self, parent=parent)

        self._writer_format = ProjectFormat()
        self._reader_format = ProjectFormat()
        self._export_format = ProjectFormat()

        self._mark_item_to_outline_item = {}
        self._modifier = False

        self._project = Project(image_path, file_name, project_name,
                                person_name)
        self._image_path = image_path if image_path else self._project.image_path

        self._current_tool = gadget
        self._selection_option = toolbar_gadget
        self._eraser_size = eraser_size
        self._eraser_option = eraser_option

        self.__current_index = -1
        self.__mouse_press_index = -1
        self.__mouse_press_offset = QPoint()
        self.__resize_handel_pressed = False
        self.__undo_stack = QUndoStack(self)
        self._selection_item = None
        self._history_widget = None
        self._history_project_manager = None
        self._mark_item_manager = MarkItemManager()
        self._mark_item_manager.selected_item_changed.connect(
            self.selected_mark_item_changed)

        # # 创建场景
        self._workbench_scene.setObjectName("workbench_scene")

        self._is_big_img = False
        # if self._is_big_img:
        #     self.workbench_view = LoadIMGraphicsView(self._mark_item_manager, gadget, toolbar_gadget, eraser_size,
        #                                              image_path, self._workbench_scene, parent=self)
        # else:
        self.workbench_view = GraphicsViewTest(self._mark_item_manager,
                                               gadget,
                                               toolbar_gadget,
                                               eraser_size,
                                               parent=self)
        # 把场景添加到视图中
        self.workbench_view.setScene(self._workbench_scene)

        self.workbench_view.setObjectName("workbench_view")
        self.workbench_view.setContentsMargins(0, 0, 0, 0)
        self.workbench_view.setBackgroundBrush(QColor(147, 147, 147))

        # 布局
        self.tab_vertical_layout = QVBoxLayout(self)
        self._splitter1 = QSplitter(self)
        self._splitter1.setStyleSheet("margin: 0px")
        self._splitter1.addWidget(self.workbench_view)

        self._splitter2 = QSplitter(self)
        self._splitter2.setOrientation(Qt.Vertical)
        self._splitter2.setStyleSheet("margin: 0px")
        self._splitter2.addWidget(self._splitter1)

        self.tab_vertical_layout.addWidget(self._splitter2)
        self.tab_vertical_layout.setContentsMargins(0, 0, 0, 0)

        # 当前选择小工具
        self.change_gadget(gadget)

        # 信号接收
        self.workbench_view.border_moved_signal.connect(self.border_moved)
        self.workbench_view.border_created.connect(self.created_border)
        self.workbench_view.about_to_create_border.connect(
            self.about_to_create_border)
        self.workbench_view.eraser_action_signal.connect(self.eraser_action)

        if all([image_path, project_name, file_name]) and not self._is_big_img:
            self.create_document()
Example #7
0
class Document(QWidget, ProjectDocument):
    mark_item_created = pyqtSignal(MarkItem)
    added_mark_item = pyqtSignal(Project, MarkItem)
    browser_result_signal = pyqtSignal(bool)
    selected_mark_item_changed = pyqtSignal(MarkItem)

    def __init__(self,
                 gadget,
                 toolbar_gadget,
                 file_name=None,
                 project_name=None,
                 image_path=None,
                 person_name=None,
                 parent=None,
                 eraser_size=3,
                 eraser_option=SelectionOptionToolBar.Subtract):
        super(Document, self).__init__(parent)
        ProjectDocument.__init__(self, parent=parent)

        self._writer_format = ProjectFormat()
        self._reader_format = ProjectFormat()
        self._export_format = ProjectFormat()

        self._mark_item_to_outline_item = {}
        self._modifier = False

        self._project = Project(image_path, file_name, project_name,
                                person_name)
        self._image_path = image_path if image_path else self._project.image_path

        self._current_tool = gadget
        self._selection_option = toolbar_gadget
        self._eraser_size = eraser_size
        self._eraser_option = eraser_option

        self.__current_index = -1
        self.__mouse_press_index = -1
        self.__mouse_press_offset = QPoint()
        self.__resize_handel_pressed = False
        self.__undo_stack = QUndoStack(self)
        self._selection_item = None
        self._history_widget = None
        self._history_project_manager = None
        self._mark_item_manager = MarkItemManager()
        self._mark_item_manager.selected_item_changed.connect(
            self.selected_mark_item_changed)

        # # 创建场景
        self._workbench_scene.setObjectName("workbench_scene")

        self._is_big_img = False
        # if self._is_big_img:
        #     self.workbench_view = LoadIMGraphicsView(self._mark_item_manager, gadget, toolbar_gadget, eraser_size,
        #                                              image_path, self._workbench_scene, parent=self)
        # else:
        self.workbench_view = GraphicsViewTest(self._mark_item_manager,
                                               gadget,
                                               toolbar_gadget,
                                               eraser_size,
                                               parent=self)
        # 把场景添加到视图中
        self.workbench_view.setScene(self._workbench_scene)

        self.workbench_view.setObjectName("workbench_view")
        self.workbench_view.setContentsMargins(0, 0, 0, 0)
        self.workbench_view.setBackgroundBrush(QColor(147, 147, 147))

        # 布局
        self.tab_vertical_layout = QVBoxLayout(self)
        self._splitter1 = QSplitter(self)
        self._splitter1.setStyleSheet("margin: 0px")
        self._splitter1.addWidget(self.workbench_view)

        self._splitter2 = QSplitter(self)
        self._splitter2.setOrientation(Qt.Vertical)
        self._splitter2.setStyleSheet("margin: 0px")
        self._splitter2.addWidget(self._splitter1)

        self.tab_vertical_layout.addWidget(self._splitter2)
        self.tab_vertical_layout.setContentsMargins(0, 0, 0, 0)

        # 当前选择小工具
        self.change_gadget(gadget)

        # 信号接收
        self.workbench_view.border_moved_signal.connect(self.border_moved)
        self.workbench_view.border_created.connect(self.created_border)
        self.workbench_view.about_to_create_border.connect(
            self.about_to_create_border)
        self.workbench_view.eraser_action_signal.connect(self.eraser_action)

        if all([image_path, project_name, file_name]) and not self._is_big_img:
            self.create_document()

    @property
    def is_big_img(self):
        return self._is_big_img

    def about_to_cmp(self, project_documents: ProjectDocument = None):
        if not self._history_widget:
            self._history_project_manager = HistoryProjectManager(
                project_documents)

            self._history_widget = Thumbnail(self._history_project_manager,
                                             self)
            self._history_project_manager.set_scene(
                self._history_widget.current_project())
            self._splitter1.addWidget(self._history_project_manager.get_view())
            self._splitter2.addWidget(self._history_widget)

            self.workbench_view.set_is_comparing(True)
            self._history_project_manager.get_view().set_is_comparing(True)

            self._history_widget.selected_project_changed.connect(
                self._selected_history_project_changed)
            self._history_widget.close_event_signal.connect(
                self._toggle_cmp_history)
            self._history_widget.synchronize_changed_signal.connect(
                self._toggle_synchronize_view)

            items = project_documents[0].project().get_mark_items()
            for item in items:
                self._project.add_mark_item(item)

        else:
            self._toggle_cmp_history(True)
            self._history_widget.setHidden(False)

        if True:
            self.connect_to_synchronize_view()

    def had_cmp(self):
        return bool(self._history_widget)

    def _toggle_synchronize_view(self, is_synchronize: bool):
        if is_synchronize:
            self.connect_to_synchronize_view()
        else:
            self.disconnect_to_asynchronous_view()

    def connect_to_synchronize_view(self):
        self._history_project_manager.synchronize_with_origin_view(
            self.workbench_view)
        self._history_project_manager.get_view().connect_to_synchronize_with(
            self.workbench_view)
        self.workbench_view.connect_to_synchronize_with(
            self._history_project_manager.get_view())

    def disconnect_to_asynchronous_view(self):
        self._history_project_manager.get_view(
        ).disconnect_to_asynchronous_with(self.workbench_view)
        self.workbench_view.disconnect_to_asynchronous_with(
            self._history_project_manager.get_view())

    def _toggle_cmp_history(self, is_on: bool):
        self._history_project_manager.hidden_view(not is_on)
        self.workbench_view.set_is_comparing(is_on)
        self._history_project_manager.get_view().set_is_comparing(is_on)

    def _selected_history_project_changed(self, project_doc: ProjectDocument):
        self._history_project_manager.set_scene(project_doc)
        self._history_project_manager.synchronize_with_origin_view(
            self.workbench_view)

    def modifier(self):
        return not self.__undo_stack.isClean()

    def set_project(self, project: Project):
        self._project = project
        if not self._image_path:
            self._image_path = project.image_path
        if not self._is_big_img:
            self.load_document(self._image_path)
        for mark_item in self._project.get_mark_items():
            self.add_mark_item(mark_item)

    def set_current_mark_item(self, mark_item: MarkItem):
        """"""
        if not mark_item:
            return
        item = [
            item for item in self._workbench_scene.items()
            if isinstance(item, OutlineItem) and item.mark_item() == mark_item
        ]
        if item:
            self._mark_item_manager.set_selected_item(item[0])
            self.workbench_view.centerOn(item[0])

    def delete_mark_item(self, mark_item: [MarkItem, OutlineItem]):
        if not mark_item:
            return
        if isinstance(mark_item, MarkItem):
            if self._mark_item_manager.selected_mark_item().mark_item(
            ) == mark_item:
                self._mark_item_manager.set_selected_item(None)
            self._project.remove_mark_item(mark_item)
            item = [
                item for item in self._workbench_scene.items() if
                isinstance(item, OutlineItem) and item.mark_item() == mark_item
            ]
            if item:
                self._mark_item_manager.unregister_mark_item(
                    mark_item.item_name)
                self._workbench_scene.removeItem(item[0])
                del item[0]

        elif isinstance(mark_item, OutlineItem):
            if self._mark_item_manager.selected_mark_item() == mark_item:
                self._mark_item_manager.set_selected_item(None)
            self._project.remove_mark_item(mark_item.mark_item())
            self._mark_item_manager.unregister_mark_item(mark_item.item_name)
            self._workbench_scene.removeItem(mark_item)
            del mark_item

    def project(self) -> Project:
        return self._project

    def project_name(self):
        return self._project.project_name

    def undo_stack(self):
        return self.__undo_stack

    def create_document(self):
        self.load_document(self._image_path)
        self.save_project()

    def save_project(self):
        self.writer_format.save_project(self._project)
        self.__undo_stack.clear()

    def export_result(self, path, progress):
        self.writer_format.export_result(path, self._project,
                                         self._image.size(), self)

    def get_file_name(self):
        return self._project.project_full_path()

    def get_project_name(self):
        return self._project.parent()

    def about_to_create_border(self):
        if self._selection_option == SelectionOptionToolBar.Replace:
            self._workbench_scene.removeItem(self._selection_item)
            self._selection_item = None

    def cancel_selection(self):
        self._workbench_scene.removeItem(self._selection_item)
        self._selection_item.disconnect()
        self._selection_item = None

    def selection_as_mark_item(self):
        """TODO"""

    def created_border(self, border: SelectionItem):

        if self._selection_option == SelectionOptionToolBar.Replace:
            self._workbench_scene.removeItem(self._selection_item)
            self._selection_item = border

            self.__undo_stack.push(
                AddSelectionItem(self._workbench_scene, self._selection_item))

        elif self._selection_option == SelectionOptionToolBar.Subtract:
            if self._selection_item:
                self._selection_item -= border
        elif self._selection_option == SelectionOptionToolBar.Add:
            if not self._selection_item:
                self._selection_item = border
            else:
                self._selection_item += border
        elif self._selection_option == SelectionOptionToolBar.Intersect:
            if self._selection_item:
                self._selection_item &= border

        if self._selection_item:
            if self._selection_item.is_empty():
                self._workbench_scene.removeItem(self._selection_item)
                self._selection_item = None
                return

            self.workbench_view.view_zoom_signal.connect(
                self._selection_item.set_pen_width_by_scale)
            self._selection_item.cancel_selection_signal.connect(
                self.cancel_selection)
            self._selection_item.as_mark_item_signal.connect(
                self.selection_as_mark_item)
            self._selection_item.reverse_select_signal.connect(
                self._select_reverser_path)

    def add_border_item(self, item: SelectionItem):
        self.__undo_stack.push(AddItemCommand(self._workbench_scene, item))

    def border_moved(self, item: SelectionItem):
        self.__undo_stack.push(MoveItemCommand(item))

    def change_toolbar_gadget(self, toolbar_gadget: QAction):
        self._selection_option = toolbar_gadget.data()

    def change_eraser_option(self, option_action: QAction):
        self._eraser_option = option_action.data()

    def change_gadget(self, tool: QAction):
        if isinstance(tool, QAction):
            tool = tool.data()

        self.workbench_view.set_gadget(tool)
        if tool == ToolsToolBar.BrowserImageTool:
            self.browser_result()
            self.browser_result_signal.emit(True)
        else:
            if self._current_tool == ToolsToolBar.BrowserImageTool:
                self.end_browser()
                self.browser_result_signal.emit(False)
        self._current_tool = tool

    def eraser_size_changed(self, eraser_size: int):
        self._eraser_size = eraser_size
        self.workbench_view.set_eraser_size(eraser_size)

    def browser_result(self):
        self.workbench_view.setBackgroundBrush(QColor(Qt.black))
        self._pixmap_item.setVisible(False)
        if self.workbench_view.is_comparing():
            self._history_project_manager.browser_result()
        if self._selection_item:
            self._selection_item.setVisible(False)

    def end_browser(self):
        self.workbench_view.setBackgroundBrush(QColor(147, 147, 147))
        self._pixmap_item.setVisible(True)
        if self.workbench_view.is_comparing():
            self._history_project_manager.end_browser()
        if self._selection_item:
            self._selection_item.setVisible(True)

    def get_sub_image_in(self, item: SelectionItem) -> [QImage, None]:

        rect = item.rectangle()
        if self.is_big_img:
            """"""
            # slide_helper = SlideHelper(self.project().image_path)
            # image_from_rect = ImgFromRect(rect, slide_helper)
            # image_from_rect = image_from_rect.area_img
            # return image_from_rect
        else:

            rect_sub_image = self._image.copy(rect)
            polygon_path = item.get_path()
            polygon_sub_image = rect_sub_image

            for row in range(0, rect.width()):
                for clo in range(0, rect.height()):
                    point = QPoint(row, clo)
                    if not polygon_path.contains(point):
                        polygon_sub_image.setPixel(point, 0)
            return polygon_sub_image

    def ai_delete_outline(self, detect_policy):

        result_numpy_array = None
        width_num_array = None

        if not self._selection_item:
            image = self._image
        else:
            image = self._image.copy(self._selection_item.rectangle())

        if detect_policy == 5:
            for h in range(0, image.height(), 256):
                for w in range(0, image.width(), 256):
                    image_ = self._image.copy(QRect(w, h, 255, 255))
                    image_ = qimage2numpy(image_)
                    result = detect_one(image_)
                    numpy_array = mat_to_img(result)
                    if width_num_array is not None:
                        width_num_array = np.hstack(
                            (width_num_array, numpy_array))
                    else:
                        width_num_array = numpy_array

                if result_numpy_array is not None:
                    result_numpy_array = np.vstack(
                        (result_numpy_array, width_num_array))
                else:
                    result_numpy_array = width_num_array
                width_num_array = None

            print(result_numpy_array.shape)
            return result_numpy_array

    def _get_outlines(self, numpy_array, detect_policy):
        outline_path1 = QPainterPath()
        outline_path2 = QPainterPath()
        outline1, outline2 = detect_outline(detect_policy,
                                            numpy_array,
                                            drop_area=80)

        for array in outline1:
            sub_path = []
            for point in array[0]:
                point = self._selection_item.mapToScene(
                    point[0][0], point[0][1])
                sub_path.append(point)

            polygon = QPolygonF(sub_path)
            path = QPainterPath()
            path.addPolygon(polygon)
            outline_path1 += path

        for array in outline2:
            sub_path = []
            for point in array[0]:
                point = self._selection_item.mapToScene(
                    point[0][0], point[0][1])
                sub_path.append(point)

            polygon = QPolygonF(sub_path)
            path = QPainterPath()
            path.addPolygon(polygon)
            outline_path2 += path

        return outline_path1, outline_path2

    def _get_outline_by_no_selection(self, numpy_array, detect_policy):
        outline_path1 = QPainterPath()
        outline_path2 = QPainterPath()
        outline1, outline2 = detect_outline(detect_policy,
                                            numpy_array,
                                            drop_area=80)

        for array in outline1:
            sub_path = []
            for point in array[0]:
                point = QPoint(point[0][0], point[0][1])
                sub_path.append(point)

            polygon = QPolygonF(sub_path)
            path = QPainterPath()
            path.addPolygon(polygon)
            outline_path1 += path

        for array in outline2:
            sub_path = []
            for point in array[0]:
                point = QPoint(point[0][0], point[0][1])
                sub_path.append(point)

            polygon = QPolygonF(sub_path)
            path = QPainterPath()
            path.addPolygon(polygon)
            outline_path2 += path

        return outline_path1, outline_path2

    def _to_create_mark_item(self, outline_path1, outline_path2):
        use_outline1_flag = True
        if not outline_path1.isEmpty():
            self.create_mark_item(outline_path1)
        elif not outline_path2.isEmpty():
            self.create_mark_item(outline_path2)
            use_outline1_flag = False
        if self._selection_item:
            self._selection_item.setFlag(QGraphicsItem.ItemIsMovable, False)
            if use_outline1_flag and not outline_path2.isEmpty():
                self._selection_item.set_reverser_path(outline_path2)

    def detect_outline(self, detect_policy):
        """
        将选中的选区对应的部分图片copy出来,然后转为ndarray类型
        用来转为OpenCV识别轮廓的输入数据
        :param detect_policy: 用哪种识别算法识别轮廓
        :return: None
        """

        if detect_policy >= 5:

            numpy_array = self.ai_delete_outline(detect_policy)
            outline_path1, outline_path2 = self._get_outline_by_no_selection(
                numpy_array, detect_policy)

            if not self._selection_item:
                self._selection_item = SelectionItem(
                    QPoint(0, 0), self._workbench_scene,
                    self.workbench_view.transform().m11())
                path = QPainterPath()
                path.addRect(
                    QRectF(0, 0, self._image.width(), self._image.height()))
                self._selection_item.set_item_path_by_path(path)
                self._selection_item.reverse_select_signal.connect(
                    self._select_reverser_path)
            self._to_create_mark_item(outline_path1, outline_path2)
            return

        if not self._selection_item:
            QMessageBox.warning(self, "警告", "没有选择区域!")
            return

        if isinstance(self._selection_item, SelectionItem):

            outline_path1 = QPainterPath()
            outline_path2 = QPainterPath()
            if detect_policy == 4:
                self._workbench_scene.removeItem(self._selection_item)
                outline_path1 = self._selection_item.mapToScene(
                    self._selection_item.get_path())
                self._selection_item = None
            else:
                sub_img = self.get_sub_image_in(self._selection_item)
                if sub_img is None:
                    return
                if isinstance(sub_img, QImage):
                    sub_img = qimage2numpy(sub_img)
                outline_path1, outline_path2 = self._get_outlines(
                    sub_img, detect_policy)
            self._to_create_mark_item(outline_path1, outline_path2)

    def correction_outline(self, option):
        """"""
        if not self._selection_item:
            return
        mark_items = [
            item for item in self._workbench_scene.items(
                self._selection_item.get_scene_path())
            if isinstance(item, OutlineItem)
        ]
        for mark_item in mark_items:
            if mark_item.locked():
                continue
            elif option == 1:
                mark_item += self._selection_item
                self._mark_item_manager.set_selected_item(mark_item)
                break
            elif option == 2:
                mark_item -= self._selection_item
                self._mark_item_manager.set_selected_item(mark_item)
                break
        self._workbench_scene.removeItem(self._selection_item)
        self._selection_item = None

    def eraser_action(self, eraser_area: SelectionItem):
        if self._selection_item:
            eraser_area &= self._selection_item
        if eraser_area.is_empty():
            return

        mark_items = [
            item for item in self._workbench_scene.items(
                eraser_area.get_scene_path()) if isinstance(item, OutlineItem)
        ]

        # if self._eraser_option == SelectionOptionToolBar.Add:
        #     selected_item = self._mark_item_manager.selected_mark_item()
        #     if selected_item in mark_items:
        #         selected_item += eraser_area
        #     return

        for item in mark_items:
            if item.locked():
                continue
            item -= eraser_area
        self._workbench_scene.removeItem(eraser_area)
        del eraser_area

    def create_mark_item(self, outline: QPainterPath):
        item_name = self._mark_item_manager.get_unique_mark_item_name()
        new_mark_item = MarkItem(list(self._project.persons),
                                 item_name=item_name,
                                 outline_path=outline)
        self._project.add_mark_item(new_mark_item)
        self.add_mark_item(new_mark_item, True)

    def add_mark_item(self, mark_item: MarkItem, new_item=False):
        item = OutlineItem(mark_item, self._workbench_scene,
                           self.workbench_view.transform().m11())

        flag = True
        if new_item:
            flag = self.detect_intersect_with_others(item)

        if flag:
            self._mark_item_to_outline_item[mark_item] = item
            self.browser_result_signal.connect(item.is_browser_result)
            self.workbench_view.view_zoom_signal.connect(
                item.set_pen_width_by_scale)
            self._mark_item_manager.register_mark_item(item,
                                                       mark_item.item_name)

            self.added_mark_item.emit(self._project, mark_item)
            self._mark_item_manager.set_selected_item(item)

    def _select_reverser_path(self):
        if self._selection_item:
            item = self._project.get_mark_items()[-1]
            reverse_path = self._selection_item.get_reverse_path()
            self._selection_item.set_reverser_path(item.get_outline())
            item.set_outline(reverse_path)

    def detect_intersect_with_others(self, new_item: OutlineItem):

        selection_path = new_item.get_scene_path()
        mark_items = [
            item for item in self._workbench_scene.items(selection_path)
            if isinstance(item, OutlineItem)
        ]

        for mark_item in mark_items:
            if mark_item != new_item:
                new_item -= mark_item

        if new_item.get_path().isEmpty():
            self._workbench_scene.removeItem(new_item)
            del new_item
            return False
        else:
            new_item.get_path().closeSubpath()
            return True

    def paint_make_item(self, mark_item: MarkItem):

        pen = QPen()
        pen.setWidth(1)
        pen.setColor(Qt.yellow)
        self._workbench_scene.addPath(mark_item.draw_path(), pen)

    @property
    def writer_format(self):
        return self._reader_format

    @writer_format.setter
    def writer_format(self, new_writer_format):
        self._writer_format = new_writer_format

    @property
    def reader_format(self):
        return self._reader_format

    @reader_format.setter
    def reader_format(self, new_reader_format):
        self._reader_format = new_reader_format

    @property
    def export_format(self):
        return self._export_format

    @export_format.setter
    def export_format(self, new_export_format):
        self._export_format = new_export_format