def _updateButtons(self):
"""
Update button icons.
"""
sz = QSize(32, 32)
if self.orientation() == Qt.Vertical:
sz.setHeight(sz.height() / 2)
pix = QPixmap(sz)
pix.fill(Qt.transparent)
pnt = QPainter(pix)
pnt.setPen(Qt.black)
path = QPainterPath()
arrowwidth = pix.width() - 2 * 2
arrowheight = min(arrowwidth / 2, pix.height() - 2 * 2)
path.moveTo((pix.width() - arrowwidth) / 2,
(pix.height() - arrowheight) / 2)
path.lineTo((pix.width() + arrowwidth) / 2,
(pix.height() - arrowheight) / 2)
path.lineTo(pix.width() / 2, (pix.height() + arrowheight) / 2)
path.lineTo((pix.width() - arrowwidth) / 2,
(pix.height() - arrowheight) / 2)
pnt.fillPath(path, Qt.black)
pnt.end()
self._inc.setIcon(QIcon(pix))
self._dec.setIcon(QIcon(QPixmap.fromImage(pix.toImage().mirrored())))
class PaintBoard(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.__InitData()
self.__InitView()
def __InitData(self):
self.__size = QSize(280, 280)
self.__board = QPixmap(self.__size)
self.__board.fill(Qt.black)
self.__isEmpty = True
self.__lastPose = QPoint(0, 0)
self.__currentPose = QPoint(0, 0)
self.__painter = QPainter()
self.__thickness = 20
self.__penColor = QColor('white')
def __InitView(self):
self.setFixedSize(self.__size)
def paintEvent(self, paintEvent):
self.__painter.begin(self)
self.__painter.drawPixmap(0, 0, self.__board)
self.__painter.end()
def mousePressEvent(self, mouseEvent):
self.__currentPose = mouseEvent.pos()
self.__lastPose = self.__currentPose
def mouseMoveEvent(self, mouseEvent):
self.__currentPose = mouseEvent.pos()
self.__painter.begin(self.__board)
self.__painter.setPen(QPen(self.__penColor, self.__thickness))
self.__painter.drawLine(self.__lastPose, self.__currentPose)
self.__painter.end()
self.__lastPose = self.__currentPose
self.update()
def mouseReleaseEvent(self, mouseEvent):
self.__isEmpty = False
def clear(self):
self.__board.fill(Qt.black)
self.update()
self.__isEmpty = True
def isEmpty(self):
return self.__isEmpty
def getImage(self):
image = self.__board.toImage()
return image
class PaintBoard(QWidget):
def __init__(self, Parent=None):
'''
Constructor
'''
super().__init__(Parent)
self.__InitData() # 先初始化数据，再初始化界面
self.__InitView()
def __InitData(self):
self.__size = QSize(480, 460)
# 新建QPixmap作为画板，尺寸为__size
self.__board = QPixmap(self.__size)
self.__board.fill(Qt.white) # 用白色填充画板
self.__IsEmpty = True # 默认为空画板
self.EraserMode = False # 默认为禁用橡皮擦模式
self.__lastPos = QPoint(0, 0) # 上一次鼠标位置
self.__currentPos = QPoint(0, 0) # 当前的鼠标位置
self.__painter = QPainter() # 新建绘图工具
self.__thickness = 10 # 默认画笔粗细为10px
self.__penColor = QColor("black") # 设置默认画笔颜色为黑色
self.__colorList = QColor.colorNames() # 获取颜色列表
def __InitView(self):
# 设置界面的尺寸为__size
self.setFixedSize(self.__size)
def Clear(self):
# 清空画板
self.__board.fill(Qt.white)
self.update()
self.__IsEmpty = True
def ChangePenColor(self, color="black"):
# 改变画笔颜色
self.__penColor = QColor(color)
def ChangePenThickness(self, thickness=10):
# 改变画笔粗细
self.__thickness = thickness
def IsEmpty(self):
# 返回画板是否为空
return self.__IsEmpty
def GetContentAsQImage(self):
# 获取画板内容（返回QImage）
image = self.__board.toImage()
return image
def paintEvent(self, paintEvent):
# 绘图事件
# 绘图时必须使用QPainter的实例，此处为__painter
# 绘图在begin()函数与end()函数间进行
# begin(param)的参数要指定绘图设备，即把图画在哪里
# drawPixmap用于绘制QPixmap类型的对象
self.__painter.begin(self)
# 0,0为绘图的左上角起点的坐标，__board即要绘制的图
self.__painter.drawPixmap(0, 0, self.__board)
self.__painter.end()
def mousePressEvent(self, mouseEvent):
# 鼠标按下时，获取鼠标的当前位置保存为上一次位置
self.__currentPos = mouseEvent.pos()
self.__lastPos = self.__currentPos
def mouseMoveEvent(self, mouseEvent):
# 鼠标移动时，更新当前位置，并在上一个位置和当前位置间画线
self.__currentPos = mouseEvent.pos()
self.__painter.begin(self.__board)
if self.EraserMode == False:
# 非橡皮擦模式
self.__painter.setPen(QPen(self.__penColor, self.__thickness)) # 设置画笔颜色，粗细
else:
# 橡皮擦模式下画笔为纯白色，粗细为10
self.__painter.setPen(QPen(Qt.white, 10))
# 画线
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update() # 更新显示
def mouseReleaseEvent(self, mouseEvent):
self.__IsEmpty = False # 画板不再为空
class PaintBoard(QWidget):
def __init__(self, Parent=None):
super().__init__(Parent)
self.__InitData() #先初始化数据，再初始化界面
self.__InitView()
def __InitData(self):
self.__size = QSize(1024, 512)
#新建QPixmap作为画板，尺寸为__size
self.__board = QPixmap(self.__size)
self.__board.fill(Qt.white) #用白色填充画板
self.__IsEmpty = True #默认为空画板
self.EraserMode = False #默认为禁用橡皮擦模式
self.__lastPos = QPoint(0, 0) #上一次鼠标位置
self.__currentPos = QPoint(0, 0) #当前的鼠标位置
self.__painter = QPainter() #新建绘图工具
self.__thickness = 6 #默认画笔粗细为6px
self.__eraser = 20
def __InitView(self):
#设置界面的尺寸为__size
self.setFixedSize(self.__size)
def Clear(self):
#清空画板
self.__board.fill(Qt.white)
self.update()
self.__IsEmpty = True
def ChangePenThickness(self, eraser=20):
#改变橡皮画笔粗细,默认20px
self.__eraser = eraser
def IsEmpty(self):
#返回画板是否为空
return self.__IsEmpty
def GetContentAsQImage(self):
#获取画板内容（返回QImage）
image = self.__board.toImage()
return image
def paintEvent(self, paintEvent):
#绘图事件
#绘图时必须使用QPainter的实例，此处为__painter
#绘图在begin()函数与end()函数间进行
#begin(param)的参数要指定绘图设备，即把图画在哪里
#drawPixmap用于绘制QPixmap类型的对象
self.__painter.begin(self)
# 0,0为绘图的左上角起点的坐标，__board即要绘制的图
self.__painter.drawPixmap(0, 0, self.__board)
self.__painter.end()
def mousePressEvent(self, mouseEvent):
#鼠标按下时，获取鼠标的当前位置保存为上一次位置
self.__currentPos = mouseEvent.pos()
self.__lastPos = self.__currentPos
def mouseMoveEvent(self, mouseEvent):
#鼠标移动时，更新当前位置，并在上一个位置和当前位置间画线
self.__currentPos = mouseEvent.pos()
self.__painter.begin(self.__board)
if self.EraserMode == False:
#非橡皮擦模式
self.__painter.setPen(
QPen(Qt.red, 6, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin)) #设置画笔颜色，粗细
else:
#橡皮擦模式下画笔为纯白色
self.__painter.setPen(
QPen(Qt.white, self.__eraser, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
#画线
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update() #更新显示
def mouseReleaseEvent(self, mouseEvent):
self.__IsEmpty = False #画板不再为空
class PaintBoard(QWidget):
def __init__(self, Parent=None):
'''
Constructor
'''
super().__init__(Parent)
self.__InitData() #先初始化数据，再初始化界面
self.__InitView()
def __InitView(self):
self.setFixedSize(self.__size)
def __InitData(self):
self.__size = QSize(1600,1200)
self.__board = QPixmap(self.__size) #新建QPixmap作为画板，宽350px,高250px
self.__board.fill(Qt.white) #用白色填充画板
self.__IsEmpty = True #默认为空画板
self.EraserMode = False #默认为禁用橡皮擦模式
self.__lastPos = QPoint(0,0)
self.__currentPos = QPoint(0,0)
self.__painter = QPainter()
self.__thickness = 10 #默认画笔粗细为10px
self.__penColor = QColor("black") #设置默认画笔颜色为黑色
self.__colorList = QColor.colorNames() #获取颜色列表
def Clear(self):
#清空画板
self.__board.fill(Qt.white)
self.update()
self.__IsEmpty = True
def ChangePenColor(self, color="black"):
#改变画笔颜色
self.__penColor = QColor(color)
def ChangePenThickness(self, thickness=10):
#改变画笔粗细
self.__thickness = thickness
def IsEmpty(self):
#返回画板是否为空
return self.__IsEmpty
def GetContentAsQImage(self):
#获取画板内容（返回QImage）
image = self.__board.toImage()
return image
def paintEvent(self, paintEvent):
self.__painter.begin(self)
self.__painter.drawPixmap(0,0,self.__board)
self.__painter.end()
def mousePressEvent(self, mouseEvent):
self.__currentPos = mouseEvent.pos()
self.__lastPos = self.__currentPos
def mouseMoveEvent(self, mouseEvent):
self.__currentPos = mouseEvent.pos()
self.__painter.begin(self.__board)
if self.EraserMode == False:
#非橡皮擦模式
self.__painter.setPen(QPen(self.__penColor,self.__thickness)) #设置画笔颜色，粗细
else:
#橡皮擦模式下画笔为纯白色，粗细为10
self.__painter.setPen(QPen(Qt.white,10))
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update() #更新显示
def mouseReleaseEvent(self, mouseEvent):
self.__IsEmpty = False #画板不再为空
class PaintBoard(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.__size = QSize(350, 350)
# 新建画板，尺寸为__size
self.__board = QPixmap(self.__size)
self.__board.fill(Qt.white) # 用白色填充画板
self.__painter = QPainter() # 新建绘图工具
self.eraser_mode = False # 默认为禁用橡皮擦模式
self.__thickness = 6 # 默认画笔粗细为10px
self.__lastPos = QPoint(0, 0) # 上一次鼠标位置
self.__currentPos = QPoint(0, 0) # 当前的鼠标位置
self.__undo_num = 0
self.__redo_num = 0
self.__undo_list = []
self.__redo_list = []
self.__undo_list.append(self.__board.toImage())
# 设置界面的尺寸为__size
self.setFixedSize(self.__size)
def clear(self):
self.__board.fill(Qt.white)
# 清空画板
self.update()
self.__undo_list.append(self.__board.toImage())
self.__redo_list = []
self.__undo_num += 1
self.__redo_num = 0
def up(self, image):
self.__board = image
# 清空画板
self.update()
self.__undo_list.append(self.__board.toImage())
self.__redo_list = []
self.__undo_num += 1
self.__redo_num = 0
def undo(self):
if self.__undo_num > 0:
image = self.__undo_list[self.__undo_num - 1]
self.__board = QPixmap.fromImage(image)
self.update()
self.__redo_list.append(self.__undo_list.pop())
self.__redo_num += 1
self.__undo_num -= 1
def redo(self):
if self.__redo_num > 0:
image = self.__redo_list[self.__redo_num - 1]
self.__board = QPixmap(image)
self.update()
self.__undo_list.append(self.__redo_list.pop())
self.__redo_num -= 1
self.__undo_num += 1
def change_pen_thickness(self, thickness=10):
# 改变画笔粗细
self.__thickness = thickness
def get_content_as_image(self):
# 获取画板内容（返回QImage）
image = self.__board.toImage()
return image
def paintEvent(self, paint_event):
# 绘图事件
# 绘图时必须使用QPainter的实例，此处为__painter
# 绘图在begin()函数与end()函数间进行
# begin(param)的参数要指定绘图设备，即把图画在哪里
self.__painter.begin(self)
# 0,0为绘图的左上角起点的坐标，__board即要绘制的图
self.__painter.drawPixmap(0, 0, self.__board)
self.__painter.end()
def mouse_press_event(self, mouse_event):
# 鼠标按下时，获取鼠标的当前位置保存为上一次位置
# self.__currentPos = mouse_event.pos()
self.__currentPos.setX(mouse_event.pos().x() - 803)
self.__currentPos.setY(mouse_event.pos().y() - 147)
self.__lastPos = self.__currentPos
def mouse_move_event(self, mouse_event):
# self.__currentPos = mouse_event.pos()
# 鼠标移动时，更新当前位置，并在上一个位置和当前位置间画线
self.__currentPos.setX(mouse_event.pos().x() - 803)
self.__currentPos.setY(mouse_event.pos().y() - 147)
self.__painter.begin(self.__board)
if not self.eraser_mode:
# 非橡皮擦模式
self.__painter.setPen(QPen(Qt.black,
self.__thickness)) # 设置画笔颜色，粗细
else:
# 橡皮擦模式下画笔为纯白色，粗细为10
self.__painter.setPen(QPen(Qt.white, self.__thickness))
# 画线
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update() # 更新显示
def mouse_release_event(self, mouse_event):
self.__undo_list.append(self.__board.toImage())
self.__redo_list = []
self.__undo_num += 1
self.__redo_num = 0
class PaintBoard(QWidget):
set_paint = pyqtSignal(bool)
def __init__(self, signals: ClientSignal, Parent=None):
'''
Constructor
'''
super().__init__(Parent)
self.Signals = signals
# 是否是本玩家在画图
# 判断是否需要发送画图信息
self.Painting = False
self.BoardSize = QSize(*board_resolution)
# 新建QPixmap作为画板，尺寸为size
self.Board = QPixmap(self.BoardSize)
self.Board.fill(Qt.white) # 用白色填充画板
self.IsEmpty = True # 默认为空画板
self.EraserMode = False # 默认为禁用橡皮擦模式
self.LastPos = QPoint(0, 0) # 上一次鼠标位置
self.CurrentPos = QPoint(0, 0) # 当前的鼠标位置
self.Painter = QPainter() # 新建绘图工具
self.Thickness = default_thickness # 默认画笔粗细为10px
self.PenColor = QColor(default_color) # 设置默认画笔颜色为黑色
self.ColorList = QColor.colorNames() # 获取颜色列表
self.set_paint.connect(self.set_painting)
self.PaintPoints = []
self.init_view()
def init_view(self):
# 设置界面的尺寸为size
self.setFixedSize(self.BoardSize)
def set_painting(self, painting):
# print('seting painting to', painting)
self.Painting = painting
def set_pen_thickness(self, thickness):
self.Thickness = int(thickness)
def set_pen_color(self, color):
self.PenColor = QColor(color)
def set_eraser(self, e):
self.EraserMode = e
if self.Painting:
self.Signals.EraserChangeSignal.emit(e)
# self.EraserSender.emit(e)
def clear(self):
if self.Painting:
self.Signals.ClearSignal.emit()
# self.ClearSender.emit()
# 清空画板
self.Board.fill(Qt.white)
self.repaint()#update()
self.IsEmpty = True
def change_pen_color(self, color="black"):
print('color changed:', color)
if self.Painting:
self.Signals.ColorChangeSignal.emit(color)
# self.ColorSender.emit(color)
# 改变画笔颜色
self.PenColor = QColor(color)
def change_pen_thickness(self, thickness=default_thickness):
if self.Painting:
self.Signals.ThicknessChangeSignal.emit(thickness)
# self.ThicknessSender.emit(thickness)
# 改变画笔粗细
self.Thickness = thickness
# print('thickness:',type(self.thickness), self.thickness)
# 返回画板是否为空
def is_empty(self):
return self.IsEmpty
def get_content_as_QImage(self):
# 获取画板内容（返回QImage）
image = self.Board.toImage()
return image
def paintEvent(self, paintEvent):
# 绘图事件
# 绘图时必须使用QPainter的实例，此处为painter
# 绘图在begin()函数与end()函数间进行
# begin(param)的参数要指定绘图设备，即把图画在哪里
# drawPixmap用于绘制QPixmap类型的对象
self.Painter.begin(self)
# 0,0为绘图的左上角起点的坐标，board即要绘制的图
self.Painter.drawPixmap(0, 0, self.Board)
self.Painter.end()
def mousePressEvent(self, mouseEvent):
# 鼠标按下时，获取鼠标的当前位置保存为上一次位置
self.CurrentPos = mouseEvent.pos()
self.LastPos = self.CurrentPos
if self.Painting:
self.Signals.ClickPointSignal.emit(mouseEvent.pos())
# self.click_point_sender.emit(mouseEvent.pos())
def mouseMoveEvent(self, mouseEvent):
# print('moving! painting=', self.Painting)
if self.Painting:
# 鼠标移动时，更新当前位置，并在上一个位置和当前位置间画线
self.CurrentPos = mouseEvent.pos()
self.paint_point()
# print('painting...')
self.repaint()
# print('complete painting...')
self.LastPos = self.CurrentPos
# self.paint_points.append([self.currentPos.x(), self.currentPos.y()])
# self.paint_point_sender.emit(mouseEvent.pos())
self.Signals.PaintPointSignal.emit(mouseEvent.pos())
def mouseReleaseEvent(self, mouseEvent):
self.IsEmpty = False # 画板不再为空
if self.Painting:
self.Signals.ReleasePointSignal.emit()
# self.release_point_sender.emit()
# self.paint_points.clear()
def paint_point(self):
self.Painter.begin(self.Board)
if not self.EraserMode:
# 非橡皮擦模式
self.Painter.setPen(QPen(self.PenColor, self.Thickness)) # 设置画笔颜色，粗细
else:
# 橡皮擦模式下画笔为纯白色，粗细为10
self.Painter.setPen(QPen(Qt.white, 10))
# 画线
self.Painter.drawLine(self.LastPos, self.CurrentPos)
self.Painter.end()
def extern_click(self, x, y):
self.LastPos = QPoint(x, y)
self.CurrentPos = QPoint(x, y)
def extern_paint(self, ps):
for x,y in ps:
self.CurrentPos = QPoint(x, y)
self.paint_point()
self.LastPos = self.CurrentPos
self.repaint()
def reset_last_point(self, x, y):
self.LastPos = QPoint(x, y)
self.CurrentPos = QPoint(x, y)
class PaintBoard(QWidget):
# Define virtual panel coordinates for different shapes/regions
VPCoord_Start = [316, 332] #LeftTopX, Y
VPCoord_Circle = [316, 332, 336, 363] #LeftTopX, Y, RightBotX, Y
VPCoord_Rect = [336, 332, 356, 363] #LeftTopX, Y, RightBotX, Y
VPCoord_Tri = [316, 363, 336, 395] #LeftTopX, Y, RightBotX, Y
VPCoord_Line = [336, 363, 356, 395] #LeftTopX, Y, RightBotX, Y
# A flag to check if the user is currently using the virtual panel
usingVP = False
def __init__(self, sizeX, sizeY, Parent=None):
'''
Constructor
'''
super().__init__(Parent)
self.__InitData(sizeX,
sizeY) #Initialize Data first, then interface/view
self.__InitView()
print("Init PaintBoard")
def __InitView(self):
self.setFixedSize(self.__size)
def __InitData(self, sizeX, sizeY):
self.__size = QSize(sizeX, sizeY)
self.__board = QPixmap(
self.__size) #Make a new QPixmap as paint board，350px * 250px
self.__board.fill(Qt.white) #Fill the paint board with white
self.__IsEmpty = True #board is empty by default
self.EraserMode = False #eraser mode is disabled by default
self.__lastPos = None
self.__currentPos = QPoint(0, 0)
self.__painter = QPainter()
self.__thickness = 1 #default pen thickness is 1
self.__penColor = QColor("black") #default color is black
self.__colorList = QColor.colorNames() #get the list of colors
def Clear(self):
#Clear the board
self.__board.fill(Qt.white)
self.update()
self.__IsEmpty = True
def ChangePenColor(self, color="black"):
self.__penColor = QColor(color)
def ChangePenThickness(self, thickness=1):
self.__thickness = thickness
def IsEmpty(self):
#Is the board empty
return self.__IsEmpty
def GetContentAsQImage(self):
#return the content of the board (return QImage)
image = self.__board.toImage()
return image
def paintEvent(self, paintEvent):
self.__painter.begin(self)
self.__painter.drawPixmap(0, 0, self.__board)
self.__painter.end()
# print("inside paintEvent")
def penPressEvent(self, pos):
self.__currentPos = QPoint(pos[0], pos[1])
self.__lastPos = self.__currentPos
def penMoveEvent(self, pos, pressure):
pen_x = pos[0]
pen_y = pos[1]
pen_pressure = pressure
if self.__lastPos is None:
self.__lastPos = QPoint(pen_x, pen_y)
elif (abs(pen_x - self.__lastPos.x()) > 21
or abs(pen_y - self.__lastPos.y()) > 21):
self.__lastPos = QPoint(pen_x, pen_y)
self.__currentPos = QPoint(pen_x, pen_y)
self.__painter.begin(self.__board)
if self.EraserMode == False:
#Non-Eraser mode
self.__painter.setPen(QPen(
self.__penColor, self.__thickness)) #Set pen color, thickness
else:
#Eraser mode: pen color is white, thickness is 6
self.__painter.setPen(QPen(Qt.white, 6))
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update() #Show updates
def penVPEvent(self, pos, pressure):
pass
'''
# Check if the pressure is over 500
if(pen_pressure > 400):
# Check which region the pen is in and prepare to draw shape accordingly
if(pen_x < self.VPCoord_Circle[2] and pen_y < self.VPCoord_Circle[3]):
print("A")
elif(pen_x < self.VPCoord_Rect[2] and pen_y < self.VPCoord_Rect[3]):
print("B")
elif(pen_x < self.VPCoord_Tri[2] and pen_y < self.VPCoord_Tri[3]):
print("C")
elif(pen_x < self.VPCoord_Line[2] and pen_y < self.VPCoord_Line[3]):
print("D")
'''
def penReleaseEvent(self, pos):
self.__IsEmpty = False #board is not empty
def paintEllipse(self, center_x, center_y, radias1, radias2):
self.__painter.begin(self.__board)
self.__painter.setPen(QPen(self.__penColor, self.__thickness))
self.__painter.drawEllipse(QPoint(center_x, center_y), radias1,
radias2)
self.__painter.end()
self.update() #Show updates
def paintRect(self, center_x, center_y, upper_left_x, upper_left_y):
width = abs(2 * (center_x - upper_left_x))
height = abs(2 * (center_y - upper_left_y))
self.__painter.begin(self.__board)
self.__painter.setPen(QPen(self.__penColor, self.__thickness))
self.__painter.drawRect(upper_left_x, upper_left_y, width, height)
self.__painter.end()
self.update() #Show updates
def paintTriangle(self, points):
self.__painter.begin(self.__board)
self.__painter.setPen(QPen(self.__penColor, self.__thickness))
self.__painter.drawPolygon(points)
self.__painter.end()
self.update() #Show updates
def paintLine(self, P1_x, P1_y, P2_x, P2_y):
P1 = QPoint(P1_x, P1_y)
P2 = QPoint(P2_x, P2_y)
self.__painter.begin(self.__board)
self.__painter.drawLine(P1, P2)
self.__painter.end()
self.update() #Show updates
class MyMainWindow(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
super(MyMainWindow, self).__init__(parent)
self.setupUi(self)
self.setMouseTracking(True)
self.imglist = []
self.ImgFolder = ''
self.CurImg = ''
#新建QPixmap作为画板，尺寸为__size
self.__board = QPixmap()
self.__board.fill(Qt.white) #用白色填充画板
self.__IsEmpty = True # 默认为空画板
self.EraserMode = False # 默认为禁用橡皮擦模式
self.__lastPos = QPoint(0, 0) # 上一次鼠标位置
self.__currentPos = QPoint(0, 0) # 当前的鼠标位置
self.__painter = QPainter() # 新建绘图工具
self.__thickness = 10 # 默认画笔粗细为10px
self.__penColor = QColor("black") # 设置默认画笔颜色为黑色
self.__colorList = QColor.colorNames() # 获取颜色列表
# 按键信号与回调函数连接
self.OpenDir.clicked.connect(self.OpenDirBntClicked)
self.NextImg.clicked.connect(self.NextImBntClicked)
self.LastImg.clicked.connect(self.PreImBntClicked)
self.SaveImg.clicked.connect(self.on_btn_Save_Clicked)
self.PenThicknessSpinBox.valueChanged.connect(self.on_PenThicknessChange)
# self.NextImg.clicked.connect(self.NextImBntClicked)
#########选择图片文件夹#########
def OpenDirBntClicked(self):
self.ImgFolder = QtWidgets.QFileDialog.getExistingDirectory(None, "select folder", DefaultImFolder) # 这个语句有些邪门
if self.ImgFolder != '':
ImNameSet = os.listdir(self.ImgFolder)
self.imglist = glob.glob(self.ImgFolder + '/*.jpg')
print(self.imglist)
print(ImNameSet)
ImNameSet.sort()
# ImPath = os.path.join(ImFolder, ImNameSet[0])
ImPath = os.path.join(self.ImgFolder, ImNameSet[1])
# pix = QtGui.QPixmap(ImPath)
# self.ImgShowLabel.setPixmap(pix)
# 画板
# self.__board = QtGui.QPixmap(r'C:\Users\49942\Pictures\Saved Pictures\t2.jpg')
self.__board = QtGui.QPixmap(self.imglist[0])
self.__board = self.__board.scaled(500,500)
# self.__IsEmpty = True # 默认为空画板
# self.EraserMode = False # 默认为禁用橡皮擦模式
#
# self.__lastPos = QPoint(0, 0) # 上一次鼠标位置
# self.__currentPos = QPoint(0, 0) # 当前的鼠标位置
#
# self.__painter = QPainter() # 新建绘图工具
#
# self.__thickness = 5 # 默认画笔粗细为10px
# self.__penColor = QColor("black") # 设置默认画笔颜色为黑色
# self.__colorList = QColor.colorNames() # 获取颜色列表
# 界面标题
self.ImNameSet = ImNameSet
self.CurImId = 0
_, SelectFolderName = os.path.split(self.ImgFolder)
CopyImFolderName = 'From{}CopyIm_{}-{}-{}-{}'.format(SelectFolderName, Month, Day, Hour, Minute)
self.CopyImFolder = os.path.join(CurFolder, CopyImFolderName)
_translate = QtCore.QCoreApplication.translate
CurWinTitle = "检测工具 " + \
" " + \
SelectFolderName + '\\' + ImNameSet[0]
self.setWindowTitle(_translate("MainWindow", '审查工具 '+self.imglist[0]))
else:
print('请重新选择文件夹')
#########显示下一张图片 #########
def NextImBntClicked(self):
ImFolder = self.ImgFolder
# ImNameSet = self.ImNameSet
CurImId = self.CurImId
ImNum = len(self.imglist)
if CurImId < ImNum - 1: # 不可循环看图
ImPath = os.path.join(ImFolder, self.imglist[CurImId + 1])
self.__board = QtGui.QPixmap(self.imglist[CurImId + 1])
self.__board = self.__board.scaled(500, 500)
self.update()
# self.ImgShowLabel.setPixmap(pix)
self.CurImId = CurImId + 1
_, SelectFolderName = os.path.split(ImFolder)
_translate = QtCore.QCoreApplication.translate
CurWinTitle = "审查图片 " + \
" " + \
SelectFolderName + '\\'
self.setWindowTitle(_translate("MainWindow", self.imglist[CurImId + 1]))
#########显示前一张图片 #########
def PreImBntClicked(self):
ImFolder = self.ImgFolder
ImNameSet = self.ImNameSet
CurImId = self.CurImId
ImNum = len(self.imglist)
if CurImId > 0: # 第一张图片没有前一张
ImPath = os.path.join(ImFolder, ImNameSet[CurImId - 1])
self.__board = QtGui.QPixmap(self.imglist[CurImId - 1])
self.__board = self.__board.scaled(500,500)
self.update()
# self.ImgShowLabel.setPixmap(pix)
self.CurImId = CurImId - 1
_, SelectFolderName = os.path.split(ImFolder)
_translate = QtCore.QCoreApplication.translate
CurWinTitle = "看图工具1.0 " + \
" " + \
SelectFolderName + '\\'
self.setWindowTitle(_translate("MainWindow", self.imglist[CurImId - 1]))
if self.CurImId < 0:
self.CurImId = 0
def Clear(self):
# 清空画板
self.__board.fill(Qt.white)
self.update()
self.__IsEmpty = True
def ChangePenColor(self, color="black"):
# 改变画笔颜色
self.__penColor = QColor(color)
def ChangePenThickness(self, thickness=10):
# 改变画笔粗细
self.__thickness = thickness
def IsEmpty(self):
# 返回画板是否为空
return self.__IsEmpty
def GetContentAsQImage(self):
# 获取画板内容（返回QImage）
image = self.__board.toImage()
return image
def paintEvent(self, paintEvent):
# 绘图事件
# 绘图时必须使用QPainter的实例，此处为__painter
# 绘图在begin()函数与end()函数间进行
# begin(param)的参数要指定绘图设备，即把图画在哪里
# drawPixmap用于绘制QPixmap类型的对象
self.__painter.begin(self)
# 0,0为绘图的左上角起点的坐标，__board即要绘制的图
self.__painter.drawPixmap(0, 0, self.__board)
self.__painter.end()
def mousePressEvent(self, mouseEvent):
# 鼠标按下时，获取鼠标的当前位置保存为上一次位置
self.__currentPos = mouseEvent.pos()
self.__lastPos = self.__currentPos
def mouseMoveEvent(self, mouseEvent):
# 鼠标移动时，更新当前位置，并在上一个位置和当前位置间画线
self.__currentPos = mouseEvent.pos()
if mouseEvent.buttons() == QtCore.Qt.LeftButton:
self.__painter.begin(self.__board)
if self.EraserMode == False:
# 非橡皮擦模式
self.__painter.setPen(QPen(self.__penColor, self.__thickness)) # 设置画笔颜色，粗细
else:
# 橡皮擦模式下画笔为纯白色，粗细为10
self.__painter.setPen(QPen(Qt.white, 10))
# 画线
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update() # 更新显示
self.mouseEventpos = mouseEvent.pos()
# pos = self.mapToGlobal(mouseEvent.pos()) #相對位置轉絕對
# print(pos)
pos = QCursor.pos()
hwnd = win32gui.WindowFromPoint((pos.x(), pos.y()))
print('x,y', pos.x(), pos.y())
print(*win32gui.GetWindowRect(hwnd))
# self.frameWidget.setRect(*win32gui.GetWindowRect(hwnd))
# 截图
screen = QApplication.primaryScreen() # 获取主显示屏对象（QScreen对象）
if screen is not None:
image = screen.grabWindow(0, pos.x() - 60, pos.y() - 60, 120, 120)
if not image.isNull():
self.EnlargeImg.setPixmap(image.scaled(240, 240))
# self.EnlargeImg.update()
def mouseReleaseEvent(self, mouseEvent):
self.__IsEmpty = False # 画板不再为空
# def leaveEvent(self, event):
# # super(Label, self).leaveEvent(event)
# # 得到鼠标在屏幕中的位置
# print('鼠标离开')
# print(event)
# pos = QCursor.pos()
# print(pos)
# hwnd = win32gui.WindowFromPoint((pos.x(), pos.y()))
# print('x,y', pos.x(), pos.y())
# print(*win32gui.GetWindowRect(hwnd))
# # self.frameWidget.setRect(*win32gui.GetWindowRect(hwnd))
# # 截图
# screen = QApplication.primaryScreen() # 获取主显示屏对象（QScreen对象）
# if screen is not None:
# image = screen.grabWindow(0, pos.x() - 60, pos.y() - 60, 120, 120)
# if not image.isNull():
# self.EnlargeImg.setPixmap(image.scaled(240, 240))
# # self.EnlargeImg.update()
def on_PenColorChange(self):
color_index = self.__comboBox_penColor.currentIndex()
color_str = self.__colorList[color_index]
self.__paintBoard.ChangePenColor(color_str)
def on_PenThicknessChange(self):
penThickness = self.__spinBox_penThickness.value()
self.__paintBoard.ChangePenThickness(penThickness)
def on_btn_Save_Clicked(self):
# savePath = QFileDialog.getSaveFileName(self, 'Save Your Paint', '.\\', '*.png')
# print(savePath)
curImg = self.imglist[self.CurImId]
ImgName = os.path.split(curImg)[-1]
savePath = os.path.join(r'C:\Users\49942\Pictures', ImgName)
print('保存')
print(savePath)
if savePath == "":
print("Save cancel")
return
image = self.__board.toImage()
image.save(savePath)
def on_cbtn_Eraser_clicked(self):
if self.__cbtn_Eraser.isChecked():
self.__paintBoard.EraserMode = True # 进入橡皮擦模式
else:
self.__paintBoard.EraserMode = False # 退出橡皮擦模式
def Quit(self):
self.close()
class PaintBoard(QWidget):
def __init__(self, Parent=None):
super().__init__(Parent)
self.__init_data()
self.__init_view()
def __init_data(self):
"""
initial the canvas, painter
:return:
"""
self.__size = QSize(420, 420)
# create a new canvas by QPixmap, size for self.__size
self.__canvas = QPixmap(self.__size)
# set the background of the board as white, for better visual effect
self.__canvas.fill(Qt.white)
# default for none
self.__IsEmpty = True
# default for no eraser
self.EraserMode = False
# initial the last mouse position
self.__lastPos = QPoint(0, 0)
# initial the current mouse position
self.__currentPos = QPoint(0, 0)
# new a painter for drawing
self.__painter = QPainter()
# default pen size for 10px
self.__thickness = 30
# default pen color for black
self.__penColor = QColor("black")
# get the color list from library
self.colorList = QColor.colorNames()
def __init_view(self):
"""
set the initial size of the canvas
:return:
"""
self.setFixedSize(self.__size)
def clear(self):
"""
clear the canvas
:return:
"""
self.__canvas.fill(Qt.white)
self.update()
self.__IsEmpty = True
def pen_color(self, color="black"):
"""
set the color of the pen
:param color:
:return:
"""
self.__penColor = QColor(color)
def pen_size(self, thick=40):
"""
set the size of the pen
:param thick:
:return:
"""
self.__thickness = thick
def is_empty(self):
"""
return the canvas is empty or not
:return:
"""
return self.__IsEmpty
def get_current_image(self):
"""
fet the current content of the canvas, return as an image
:return:
"""
current_image = self.__canvas.toImage()
return current_image
def paintEvent(self, paintEvent):
"""
the painter works between begin() and end()
- begin(param): parameter--canvas
- drawPixmap: paint QPixmap object
0, 0 start
:param paintEvent:
:return:
"""
self.__painter.begin(self)
self.__painter.drawPixmap(0, 0, self.__canvas)
self.__painter.end()
def mousePressEvent(self, mouseEvent):
"""
capture the mouse when pressed
:param mouseEvent:
:return:
"""
self.__currentPos = mouseEvent.pos()
self.__lastPos = self.__currentPos
def mouseMoveEvent(self, mouseEvent):
"""
when the mouse moves, update the position
:param mouseEvent:
:return:
"""
self.__currentPos = mouseEvent.pos()
self.__painter.begin(self.__canvas)
if self.EraserMode == False:
self.__painter.setPen(QPen(self.__penColor, self.__thickness))
else:
self.__painter.setPen((QPen(Qt.white, 40)))
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.__painter.end()
self.__lastPos = self.__currentPos
self.update()
def mouseReleaseEvent(self, QMouseEvent):
"""
set the canvas for not empty
:param QMouseEvent:
:return:
"""
self.__IsEmpty = False
class MainWindow(QMainWindow, Ui_mainWidget): # 为了实现窗口的显示和业务逻辑分离，新建另一个调用窗口的文件
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.board = QPixmap(865, 485)
self.board.fill(Qt.white)
self.is_empty = True # 空画板
self.last_pos = QPoint(0, 0)
self.current_pos = QPoint(0, 0)
self.painter = QPainter()
self.painter.setRenderHint(QPainter.Antialiasing) # 反锯齿
self.clearButton.clicked.connect(self.clear)
self.uploadButton.clicked.connect(self.upload)
self.runButton.clicked.connect(self.run)
# 在此处识别，调用算法中的识别函数
def run(self):
algorithm = self.algorithmCombo.currentText()
target = self.targetCombo.currentText()
print(algorithm, target)
# 先保存图片然后找到该图片识别
image = self.board.toImage()
# 这里可以改图片存储路径
image_save_path = 'images/testImage.jpg'
image.save(image_save_path)
# 为了方便，识别时直接去存储路径下获取图片
img_path = image_save_path
# 由于尚未尝试用除NN外的算法去同时识别数字+字母，所以当选择其他算法时需要输出提示信息
try:
# 需要更名选择不同的model，可能会不存在，先load下来看是否报错
model_path = model_path_dic[algorithm][target_sub[target]]
if algorithm == "SVM" or algorithm == "KNN":
model = joblib.load(model_path)
else:
model = load_model(model_path)
except: # 如果图片路径下没有相应的图片或是模型路径下没有相应的模型，报错
QMessageBox.about(self, "提示", "暂不支持")
self.resultLineEdit.setText("")
self.board.fill(Qt.white)
else:
# 运行并返回预测结果
prediction = run(img_path, model_path,
algorithmName_sub[algorithm], target_sub[target])
prediction = ' '.join([str(x) for x in prediction])
print(prediction)
self.resultLineEdit.setText(prediction) # 将结果存放在LineEdit中
self.board.load("result.png")
self.update()
def upload(self):
filename = QFileDialog.getOpenFileName(None, 'open', ".")
self.board.load(filename[0])
self.update()
def clear(self):
self.board.fill(Qt.white)
self.update()
self.is_empty = True
self.resultLineEdit.setText("")
def paintEvent(self, paintEvent):
self.painter.begin(self)
self.painter.drawPixmap(0, 0, self.board)
self.painter.end()
def mouseReleaseEvent(self, QMouseEvent):
self.is_empty = False
def mousePressEvent(self, QMouseEvent):
self.current_pos = QMouseEvent.pos()
self.last_pos = self.current_pos
def mouseMoveEvent(self, QMouseEvent):
self.current_pos = QMouseEvent.pos()
self.painter.begin(self.board)
self.painter.setPen(QPen(Qt.black, 6))
self.painter.drawLine(self.last_pos, self.current_pos)
self.painter.end()
self.last_pos = self.current_pos
self.update()
class PaintBoard(QWidget):
def __init__(self):
QWidget.__init__(self)
# self.label = QLabel(self)
# self.gridLayout = QGridLayout(self)
# self.gridLayout.addWidget(self.label)
self.pixmap = QPixmap(1,1)
self.pixmap.fill(Qt.white)
self.img = QImage(self.pixmap.toImage())
# self.label.setFrameShape(1)
# # self.label.setPixmap(self.pixmap)
# self.label.setScaledContents(True)
# self.label.setVisible(False)
self.pen = QPainter()
def paintEvent(self, paintEvent):
self.pixmap = self.pixmap.scaled(self.width(), self.height())
self.pen.begin(self)
# self.pen.drawPixmap(0, 0, self.pixmap)
self.img = QImage(self.pixmap.toImage())
self.pen.drawImage(0, 0, self.img)
self.pen.end()
def drawPoints(self, x, y):
# print(self.width(),self.height())
m = int(self.width()/2) + x
n = int(self.height()/2) - y
self.pen.begin(self.pixmap)
self.pen.setPen(QPen(Qt.black,1))
self.pen.drawPoint(m, n)
self.pen.end()
self.update()
# self.repaint()
def load_img(self, img):
self.pixmap.load(img)
self.update()
#DDA
def drawLine(self, x0, y0, x1, y1):
self.Clear()
dx = x1 - x0
dy = y1 - y0
if fabs(dx) > fabs(dy):
steps = fabs(dx)
else:
steps = fabs(dy)
self.drawPoints(int(x0+0.5), int(y0+0.5))
xInc = dx/steps
yInc = dy/steps
for i in range(int(steps+0.5)):
x0 += xInc
y0 += yInc
self.drawPoints(int(x0+0.5), int(y0+0.5))
#中点法画圆
def CirclePlot(self, xc, yc, x, y):
self.drawPoints(x+xc, y+yc)
self.drawPoints(-x+xc, y+yc)
self.drawPoints(x+xc, -y+yc)
self.drawPoints(-x+xc, -y+yc)
self.drawPoints(y+xc, x+yc)
self.drawPoints(y+xc, -x+yc)
self.drawPoints(-y+xc, x+yc)
self.drawPoints(-y+xc, -x+yc)
def drawRound(self, xc, yc, r):
self.Clear()
x = 0
y = r
d = 3-2*r
self.CirclePlot(xc, yc, x, y)
while x<y:
if d<0:
d = d+4*x+6
else:
d = d+4*(x-y)+10
y -= 1
x +=1
self.CirclePlot(xc, yc, x, y)
'''
# 边界填充
def fill(self, x, y):
w = int(self.width()/2)
h = int(self.height()/2)
block = deque([(x, y)])
while 1:
if len(block) == 0:
break
else:
# print(block)
point = block.popleft()
m = point[0]
n = point[1]
# c = self.img.pixel(w+m, h+n)
# colors = QColor(c).getRgb()
# if colors != (0, 0, 0, 255):
self.drawPoints(m, n)
# result.append((m,n))
c = self.img.pixel(w+m, h+n-1)
colors = QColor(c).getRgb()
if colors != (0, 0, 0, 255):
if (m,n-1) not in block:
block.append((m,n-1))
c = self.img.pixel(w+m, h+n+1)
colors = QColor(c).getRgb()
if colors != (0, 0, 0, 255):
if (m,n+1) not in block:
block.append((m,n+1))
c = self.img.pixel(w+m-1, h+n)
colors = QColor(c).getRgb()
if colors != (0, 0, 0, 255):
if (m-1,n) not in block:
block.append((m-1,n))
c = self.img.pixel(w+m+1, h+n)
colors = QColor(c).getRgb()
if colors != (0, 0, 0, 255):
if (m+1,n) not in block:
block.append((m+1,n))
print(results)
'''
#边界填充
#种子边界填充
def fill(self, x, y):
w = int(self.width()/2)
h = int(self.height()/2)
block = deque([(x, y)])
results = []
while 1:
if len(block) == 0:
break
else:
point = block.popleft()
m = point[0]
n = point[1]
results.append((m,n))
c = self.img.pixel(w+m, h+n-1)
colors = QColor(c).getRgb()
if colors != (0, 0, 0, 255):
if (m,n-1) not in block:
if (m,n-1) not in results:
block.append((m,n-1))
c = self.img.pixel(w+m, h+n+1)
colors = QColor(c).getRgb()
if colors != (0, 0, 0, 255):
if (m,n+1) not in block:
if (m,n+1) not in results:
block.append((m,n+1))
c = self.img.pixel(w+m-1, h+n)
colors = QColor(c).getRgb()
if colors != (0, 0, 0, 255):
if (m-1,n) not in block:
if (m-1,n) not in results:
block.append((m-1,n))
c = self.img.pixel(w+m+1, h+n)
colors = QColor(c).getRgb()
if colors != (0, 0, 0, 255):
if (m+1,n) not in block:
if (m+1,n) not in results:
block.append((m+1,n))
for point in results:
self.drawPoints(point[0], point[1])
def Clear(self):
self.pixmap.fill(Qt.white)
self.update()
