cg_gui.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sys
import cg_algorithms as alg
import copy
from typing import Optional
from PyQt5.QtWidgets import (
    QFileDialog,
    QColorDialog,
    QApplication,
    QMainWindow,
    qApp,
    QGraphicsScene,
    QGraphicsView,
    QGraphicsItem,
    QListWidget,
    QHBoxLayout,
    QWidget,
    QStyleOptionGraphicsItem)
from PyQt5.QtGui import QPainter, QMouseEvent, QColor, QIcon, QPixmap, QWheelEvent
from PyQt5.QtCore import QRectF, Qt

# 全局变量定义
color = QColor(0, 0, 0)  # 默认画笔颜色为黑色


class MyCanvas(QGraphicsView):
    """
    画布窗体类，继承自QGraphicsView，采用QGraphicsView、QGraphicsScene、QGraphicsItem的绘图框架
    """

    def __init__(self, *args):
        super().__init__(*args)
        self.main_window = None
        self.list_widget = None
        self.item_dict = {}
        self.selected_id = ''

        self.status = ''
        self.temp_algorithm = ''
        self.temp_id = ''
        self.temp_item = None
        self.temp_move = []
        self.p_list = []
        self.last_click_button = None
        self.center_p = []     # 缩放，旋转所需点
        self.base_scale = 1    # 缩放倍数
        self.r = 0             # 旋转角度
        self.windows = []      # 窗口左上和右下坐标


    def reset_canvas(self):
        self.item_dict = {}
        self.list_widget.clear()  # 清楚label
        self.scene().clear()
        self.status = ''

    def save_canvas(self, filename, w, h):
        painter = QPainter()
        pixmap = QPixmap(w, h)          # Size
        pixmap.fill(QColor(255, 255, 255)) # 背景填充
        painter.begin(pixmap)
        for i in self.item_dict:
            self.item_dict[i].paint(painter, QStyleOptionGraphicsItem)
        painter.end()
        pixmap.save(filename)

    def start_draw_line(self, algorithm, item_id):
        self.status = 'line'
        self.temp_algorithm = algorithm
        self.temp_id = item_id

    def start_draw_ellipse(self, item_id):
        self.status = 'ellipse'
        self.temp_id = item_id

    def start_draw_polygon(self, algorithm, item_id):
        self.status = 'polygon'
        self.temp_algorithm = algorithm
        self.temp_id = item_id

    def start_draw_curve(self, algorithm, item_id):
        self.status = 'curve'
        self.temp_algorithm = algorithm
        self.temp_id = item_id

    def start_translate(self):
        if self.selected_id == '':
            self.status = ''
            return
        self.status = 'translate'
        self.temp_id = self.selected_id
        # self.temp_item

    def start_rotate(self):
        '''
        此处旋转不含椭圆操作
        '''
        if self.selected_id == '' or \
                self.item_dict[self.selected_id].item_type == 'ellipse':
            self.status = ''
            return
        self.status = 'rotate'
        self.temp_id = self.selected_id

    def start_scale(self):
        if self.selected_id == '':
            self.status = ''
            return
        self.status = 'scale'
        self.temp_id = self.selected_id

    def start_clip(self, algorithm):
        if self.selected_id == '' or \
                self.item_dict[self.selected_id].item_type != 'line':
            self.status = ''
            return

        self.status = 'clip'
        self.temp_id = self.selected_id
        self.temp_algorithm = algorithm

    def finish_draw(self):
        self.temp_id = self.main_window.get_id()

    def clear_selection(self):
        if self.selected_id != '':
            self.item_dict[self.selected_id].selected = False
            self.selected_id = ''

    def selection_changed(self, selected):
        self.main_window.statusBar().showMessage('图元选择： %s' % selected)
        if self.selected_id != '':
            self.item_dict[self.selected_id].selected = False
            self.item_dict[self.selected_id].update()
        self.selected_id = selected
        self.item_dict[selected].selected = True
        self.item_dict[selected].update()
        self.status = ''
        self.updateScene([self.sceneRect()])
    def get_item_at_click(self, event):
        pos = event.pos()
        item = self.itemAt(pos)
        return item


    def wheelEvent(self, event: QWheelEvent) -> None:
        '''
        鼠标滑轮每动一格， angleY的变化值为15
        '''
        angle = event.angleDelta()/8
        angleY = angle.y()
        if self.status == 'scale':
            if angleY > 0:
                self.base_scale += 0.1
            else:
                self.base_scale -= 0.1
                if self.base_scale < 0:
                    self.base_scale = 0
            if self.center_p is not None:
                temp_list = copy.deepcopy(self.p_list)
                self.temp_item.p_list = alg.scale(temp_list, self.center_p[0], self.center_p[1], self.base_scale)
            self.updateScene([self.sceneRect()])
        elif self.status == 'rotate':
            self.r += angleY
            if self.center_p is not None:
                temp_list = copy.deepcopy(self.p_list)
                self.temp_item.p_list = alg.rotate(temp_list, self.center_p[0], self.center_p[1], self.r)
            self.updateScene([self.sceneRect()])

    def mousePressEvent(self, event: QMouseEvent) -> None:
        # item = self.get_item_at_click(event)
        # if isinstance(item, QGraphicsItem):
        #     print('YYYYYYYYYES')
        pos = self.mapToScene(event.localPos().toPoint())
        x = int(pos.x())
        y = int(pos.y())
        if self.status == 'line':
            self.temp_item = MyItem(self.temp_id, self.status, [[x, y], [x, y]], self.temp_algorithm)
            self.scene().addItem(self.temp_item)
        elif self.status == 'ellipse':
            if event.button() == Qt.LeftButton:  # 检测鼠标按键是否为左键
                self.temp_item = MyItem(self.temp_id, self.status, [[x, y], [x, y]], self.temp_algorithm)
                self.scene().addItem(self.temp_item)
        elif self.status == 'polygon':
            '''
            操作逻辑：第一次press时，记录下起点和终止点位置，同时move和release与line操作一致
            随后的press操作仅记录终止点位置，以上一次终点的位置为起点进行绘制
            最终收到右键操作时，将起点添加到p_list中，完成绘制
            '''
            if event.button() == Qt.LeftButton:
                self.last_click_button = Qt.LeftButton
                if self.temp_item is None:  # 如果为空
                    self.temp_item = MyItem(self.temp_id, self.status, [[x, y], [x, y]], self.temp_algorithm)
                    self.scene().addItem(self.temp_item)
                else:
                    self.temp_item.p_list.append([x, y])
            elif event.button() == Qt.RightButton:  # 右键操作：如果为空,默认不进行操作
                self.last_click_button = Qt.RightButton
                if self.temp_item is not None:  # 如果不为空,向p_list中添加起点
                    x = copy.deepcopy(self.temp_item.p_list[0])
                    self.temp_item.p_list.append(x)
        elif self.status == 'curve':
            if event.button() == Qt.LeftButton:
                self.last_click_button = Qt.LeftButton
                if self.temp_item is None:
                    self.temp_item = MyItem(self.temp_id, self.status, [[x, y], [x, y]], self.temp_algorithm)
                    self.scene().addItem(self.temp_item)
                else:
                    self.temp_item.p_list.append([x, y])

            elif event.button() == Qt.RightButton:  # 此处的右键仅起结束作用
                self.last_click_button = Qt.RightButton
        elif self.status == 'translate':
            '''
            Version 1.0: 直接判断press点和release点之间的dx,dy，进行平移操作
            '''
            self.temp_item = self.item_dict[self.temp_id]
            if event.button() == Qt.LeftButton:
                self.last_click_button = Qt.LeftButton
                self.temp_move = [[x, y], [x, y]]

        elif self.status == 'scale' or self.status == 'rotate':
            '''
            Version 1.0: 鼠标左键确定点,滑轮确定缩放倍数;必须先确定点，再进行缩放
            '''
            self.temp_item = self.item_dict[self.temp_id]
            if event.button() == Qt.LeftButton:
                self.p_list = copy.deepcopy(self.temp_item.p_list)
                self.last_click_button = Qt.LeftButton
                self.center_p = [x, y]
            elif event.button() == Qt.RightButton:  # 右键作为结束标志
                self.last_click_button = Qt.RightButton

        elif self.status == 'clip':
            self.temp_item = self.item_dict[self.temp_id]
            if event.button() == Qt.LeftButton:
                self.p_list = copy.deepcopy(self.temp_item.p_list)
                self.last_click_button = Qt.LeftButton
                self.windows = [[x, y], [x, y]]

        self.updateScene([self.sceneRect()])
        super().mousePressEvent(event)

    def mouseMoveEvent(self, event: QMouseEvent) -> None:

        pos = self.mapToScene(event.localPos().toPoint())
        x = int(pos.x())
        y = int(pos.y())

        if self.status == 'line':
            self.temp_item.p_list[1] = [x, y]
        elif self.status == 'ellipse':
            self.temp_item.p_list[1] = [x, y]
        elif self.status == 'polygon':
            if self.last_click_button == Qt.LeftButton:
                self.temp_item.p_list[len(self.temp_item.p_list) - 1] = [x, y]
        elif self.status == 'curve':
            if self.last_click_button == Qt.LeftButton:
                self.temp_item.p_list[len(self.temp_item.p_list) - 1] = [x, y]
        elif self.status == 'translate':
            if self.last_click_button == Qt.LeftButton:
                # self.temp_item = self.item_dict[self.temp_id]
                self.temp_move[1] = [x, y]
                dx = self.temp_move[1][0] - self.temp_move[0][0]
                dy = self.temp_move[1][1] - self.temp_move[0][1]
                self.p_list = copy.deepcopy(self.temp_item.p_list)
                self.temp_item.p_list = alg.translate(self.p_list, dx, dy)
                self.temp_move[0] = [x, y]
        elif self.status == 'clip':
            if self.last_click_button == Qt.LeftButton:
                self.windows[1] = [x, y]
                p0, p1 = self.windows[0], self.windows[1]
                temp_list = copy.deepcopy(self.p_list)
                self.temp_item.p_list = alg.clip(temp_list, p0[0], p0[1], p1[0], p1[1], self.temp_algorithm)
        self.updateScene([self.sceneRect()])
        super().mouseMoveEvent(event)

    def mouseReleaseEvent(self, event: QMouseEvent) -> None:
        if self.status == 'line':
            self.item_dict[self.temp_id] = self.temp_item
            self.list_widget.addItem(self.temp_id)
            self.temp_item = None
            self.finish_draw()
        elif self.status == 'ellipse':
            self.item_dict[self.temp_id] = self.temp_item
            self.list_widget.addItem(self.temp_id)
            self.temp_item = None
            self.finish_draw()
        elif self.status == 'polygon':
            if self.last_click_button == Qt.RightButton:
                self.item_dict[self.temp_id] = self.temp_item
                self.list_widget.addItem(self.temp_id)
                self.finish_draw()
                self.temp_item = None
                self.last_click_button = None
        elif self.status == 'curve':
            if self.last_click_button == Qt.RightButton:
                self.item_dict[self.temp_id] = self.temp_item
                self.list_widget.addItem(self.temp_id)
                self.finish_draw()
                self.temp_item = None
                self.last_click_button = None
        elif self.status == 'translate':
            if self.last_click_button == Qt.LeftButton:
                self.finish_draw()
                self.p_list = []
                self.temp_item = None
                self.last_click_button = None
                self.selected_id = ''
        elif self.status == 'scale' or self.status == 'rotate':
            if self.last_click_button == Qt.RightButton:
                self.finish_draw()
                self.center_p = []
                self.p_list = []
                self.base_scale = 1
                self.temp_item = None
                self.last_click_button = None
                self.selected_id = ''
        elif self.status == 'clip':
            if self.last_click_button == Qt.LeftButton:
                self.finish_draw()
                self.windows = []
                self.p_list = []
                self.temp_item = None
                self.last_click_button = None
                self.selected_id = ''

        super().mouseReleaseEvent(event)


class MyItem(QGraphicsItem):
    """
    自定义图元类，继承自QGraphicsItem
    """

    def __init__(self, item_id: str, item_type: str, p_list: list, algorithm: str = '', parent: QGraphicsItem = None):
        """

        :param item_id: 图元ID
        :param item_type: 图元类型，'line'、'polygon'、'ellipse'、'curve'等
        :param p_list: 图元参数
        :param algorithm: 绘制算法，'DDA'、'Bresenham'、'Bezier'、'B-spline'等
        :param parent:
        """
        super().__init__(parent)
        self.id = item_id  # 图元ID
        self.item_type = item_type  # 图元类型，'line'、'polygon'、'ellipse'、'curve'等
        self.p_list = p_list  # 图元参数
        self.algorithm = algorithm  # 绘制算法，'DDA'、'Bresenham'、'Bezier'、'B-spline'等
        self.selected = False

    def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: Optional[QWidget] = ...) -> None:
        global color  # 通过全局变量控制画笔颜色
        if self.item_type == 'line':
            painter.setPen(color)
            item_pixels = alg.draw_line(self.p_list, self.algorithm)
            for p in item_pixels:
                painter.drawPoint(*p)
            if self.selected:
                painter.setPen(QColor(255, 0, 0))
                painter.drawRect(self.boundingRect())
        elif self.item_type == 'polygon':
            painter.setPen(color)
            item_pixels = alg.draw_polygon(self.p_list, self.algorithm)
            for p in item_pixels:
                painter.drawPoint(*p)
            if self.selected:
                painter.setPen(QColor(255, 0, 0))
                painter.drawRect(self.boundingRect())
        elif self.item_type == 'ellipse':
            painter.setPen(color)
            item_pixels = alg.draw_ellipse(self.p_list)
            for p in item_pixels:
                painter.drawPoint(*p)
            if self.selected:
                painter.setPen(QColor(255, 0, 0))
                painter.drawRect(self.boundingRect())
        elif self.item_type == 'curve':
            painter.setPen(color)
            lst = copy.deepcopy(self.p_list)
            # item_pixels = alg.draw_curve(self.p_list, self.algorithm)
            item_pixels = alg.draw_curve(lst, self.algorithm)
            for p in item_pixels:
                painter.drawPoint(*p)
            if self.selected:
                painter.setPen(QColor(255, 0, 0))
                painter.drawRect(self.boundingRect())

    # TODO: 补充另外三种图元
    def boundingRect(self) -> QRectF:
        if self.item_type == 'line':
            x0, y0 = self.p_list[0]
            x1, y1 = self.p_list[1]
            x = min(x0, x1)
            y = min(y0, y1)
            w = max(x0, x1) - x
            h = max(y0, y1) - y
            return QRectF(x - 1, y - 1, w + 2, h + 2)
        elif self.item_type == 'polygon':
            x_list = [i[0] for i in self.p_list]
            y_list = [i[1] for i in self.p_list]
            x = min(x_list)
            y = min(y_list)
            w = max(x_list) - x
            h = max(y_list) - y
            return QRectF(x - 1, y - 1, w + 2, h + 2)
        elif self.item_type == 'ellipse':
            x0, y0 = self.p_list[0]
            x1, y1 = self.p_list[1]
            x = min(x0, x1)
            y = min(y0, y1)
            w = max(x0, x1) - x
            h = max(y0, y1) - y
            return QRectF(x - 1, y - 1, w + 2, h + 2)
        elif self.item_type == 'curve':
            x_list = [i[0] for i in self.p_list]
            y_list = [i[1] for i in self.p_list]
            x = min(x_list)
            y = min(y_list)
            w = max(x_list) - x
            h = max(y_list) - y
            return QRectF(x - 1, y - 1, w + 2, h + 2)


class MainWindow(QMainWindow):
    """
    主窗口类
    """

    def __init__(self):
        super().__init__()
        # self.item_cnt = -1

        # 使用QListWidget来记录已有的图元，并用于选择图元。注：这是图元选择的简单实现方法，更好的实现是在画布中直接用鼠标选择图元
        self.list_widget = QListWidget(self)
        self.list_widget.setMinimumWidth(200)

        # 使用QGraphicsView作为画布
        self.scene = QGraphicsScene(self)
        self.scene.setSceneRect(0, 0, 600, 600)
        self.canvas_widget = MyCanvas(self.scene, self)
        self.canvas_widget.setFixedSize(600, 600)
        self.canvas_widget.main_window = self
        self.canvas_widget.list_widget = self.list_widget

        # 设置图标
        icon = QIcon()
        icon.addPixmap(QPixmap(r"paint.ico"), QIcon.Normal, QIcon.Off)
        self.setWindowIcon(icon)
        # 设置菜单栏
        menubar = self.menuBar()
        file_menu = menubar.addMenu('文件')
        set_pen_act = file_menu.addAction('设置画笔')
        reset_canvas_act = file_menu.addAction('重置画布')
        save_canvas_act = file_menu.addAction('保存画布')
        exit_act = file_menu.addAction('退出')
        draw_menu = menubar.addMenu('绘制')
        line_menu = draw_menu.addMenu('线段')
        line_naive_act = line_menu.addAction('Naive')
        line_dda_act = line_menu.addAction('DDA')
        line_bresenham_act = line_menu.addAction('Bresenham')
        polygon_menu = draw_menu.addMenu('多边形')
        polygon_dda_act = polygon_menu.addAction('DDA')
        polygon_bresenham_act = polygon_menu.addAction('Bresenham')
        ellipse_act = draw_menu.addAction('椭圆')
        curve_menu = draw_menu.addMenu('曲线')
        curve_bezier_act = curve_menu.addAction('Bezier')
        curve_b_spline_act = curve_menu.addAction('B-spline')
        edit_menu = menubar.addMenu('编辑')
        translate_act = edit_menu.addAction('平移')
        rotate_act = edit_menu.addAction('旋转')
        scale_act = edit_menu.addAction('缩放')
        clip_menu = edit_menu.addMenu('裁剪')
        clip_cohen_sutherland_act = clip_menu.addAction('Cohen-Sutherland')
        clip_liang_barsky_act = clip_menu.addAction('Liang-Barsky')

        # 连接信号和槽函数
        exit_act.triggered.connect(qApp.quit)
        # Pen_signal
        set_pen_act.triggered.connect(self.set_pen_action)
        # Canvas_signal
        reset_canvas_act.triggered.connect(self.reset_canvas_action)
        save_canvas_act.triggered.connect(self.save_canvas_action)
        # Line_signal
        line_naive_act.triggered.connect(self.line_naive_action)
        line_dda_act.triggered.connect(self.line_dda_action)
        line_bresenham_act.triggered.connect(self.line_bresenham_action)
        # Polygon_signal
        polygon_dda_act.triggered.connect(self.polygon_dda_action)
        polygon_bresenham_act.triggered.connect(self.polygon_bresenham_action)
        # Ellipse_signal
        ellipse_act.triggered.connect(self.ellipse_action)
        # Curve_signal
        curve_bezier_act.triggered.connect(self.curve_bezier_action)
        curve_b_spline_act.triggered.connect(self.curve_b_spline_action)
        # Translate_signal
        translate_act.triggered.connect(self.translate_action)
        # Rotate_signal
        rotate_act.triggered.connect(self.rotate_action)
        # Scale_signal
        scale_act.triggered.connect(self.scale_action)
        # Clip_signal
        clip_cohen_sutherland_act.triggered.connect(self.clip_cohen_sutherland_action)
        clip_liang_barsky_act.triggered.connect(self.clip_liang_barsky_action)

        self.list_widget.currentTextChanged.connect(self.canvas_widget.selection_changed)

        # 设置主窗口的布局
        self.hbox_layout = QHBoxLayout()
        self.hbox_layout.addWidget(self.canvas_widget)
        self.hbox_layout.addWidget(self.list_widget, stretch=1)
        self.central_widget = QWidget()
        self.central_widget.setLayout(self.hbox_layout)
        self.setCentralWidget(self.central_widget)
        self.statusBar().showMessage('空闲')  # MainWindow对象下端状态栏
        self.resize(600, 600)
        self.setWindowTitle('CG Demo')

    def get_id(self):
        ''' # version 1: 【缺点】在进行切换时，会导致序号+1. 例如：id=0为DDA画线，切换为Naive后，所得序号为2，跨越序号1
        self.item_cnt += 1
        _id = str(self.item_cnt)
        return _id
        '''
        return str(len(self.canvas_widget.list_widget))

    # ResetCanvas Action

    # Pen Action
    def set_pen_action(self):
        global color
        color = QColorDialog.getColor()
        self.statusBar().showMessage("设置画笔")

    # Canvas Action
    def reset_canvas_action(self):
        # self.item_cnt = 0  # 重置计数
        self.canvas_widget.reset_canvas()
        self.statusBar().showMessage("重置画布")

    def save_canvas_action(self):
        self.statusBar().showMessage("保存画布")
        dialog = QFileDialog()
        file_name = dialog.getSaveFileName(filter="Image Files(*.jpg *.png *.bmp)")
        if file_name[0]:
            self.canvas_widget.save_canvas(file_name[0], 600, 600)




    # Line Action
    def line_naive_action(self):
        self.canvas_widget.start_draw_line('Naive', self.get_id())
        self.statusBar().showMessage('Naive算法绘制线段')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    def line_dda_action(self):
        self.canvas_widget.start_draw_line('DDA', self.get_id())
        self.statusBar().showMessage('DDA算法绘制线段')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    def line_bresenham_action(self):
        self.canvas_widget.start_draw_line('Bresenham', self.get_id())
        self.statusBar().showMessage('Bresenham算法绘制线段')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    # Polygon Action
    def polygon_dda_action(self):
        self.canvas_widget.start_draw_polygon('DDA', self.get_id())
        self.statusBar().showMessage('DDA算法绘制多边形')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    def polygon_bresenham_action(self):
        self.canvas_widget.start_draw_polygon('Bresenham', self.get_id())
        self.statusBar().showMessage('Bresenham算法绘制多边形')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    # Ellipse Action
    def ellipse_action(self):
        self.canvas_widget.start_draw_ellipse(self.get_id())
        self.statusBar().showMessage('椭圆绘制')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    # Curve Action
    def curve_bezier_action(self):
        self.canvas_widget.start_draw_curve('Bezier', self.get_id())
        self.statusBar().showMessage('Bezier算法绘制曲线')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    def curve_b_spline_action(self):
        self.canvas_widget.start_draw_curve('B-spline', self.get_id())
        self.statusBar().showMessage('B-spline算法绘制曲线')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    def translate_action(self):
        self.canvas_widget.start_translate()
        self.statusBar().showMessage('平移')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()


    def rotate_action(self):
        self.canvas_widget.start_rotate()
        self.statusBar().showMessage('旋转')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    def scale_action(self):
        self.canvas_widget.start_scale()
        self.statusBar().showMessage('缩放')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    def clip_cohen_sutherland_action(self):
        self.canvas_widget.start_clip('Cohen-Sutherland')
        self.statusBar().showMessage('Cohen-Sutherland算法裁剪')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()

    def clip_liang_barsky_action(self):
        self.canvas_widget.start_clip('Liang-Barsky')
        self.statusBar().showMessage('Liang-Barsky算法裁剪')
        self.list_widget.clearSelection()
        self.canvas_widget.clear_selection()


if __name__ == '__main__':
    app = QApplication(sys.argv)
    mw = MainWindow()
    mw.show()
    sys.exit(app.exec_())