def mouseReleaseEvent(self, mouse_event):
if self.span_mouse.is_started():
self.span_mouse.end_drag()
elif self.select_mouse.is_started():
self.select_mouse.end_drag()
elif self.move_mouse.is_started():
self.move_mouse.end_drag()
else:
keyboard_modifiers = QApplication.keyboardModifiers()
if self.pattern is None or keyboard_modifiers == QtCore.Qt.ControlModifier or keyboard_modifiers == QtCore.Qt.AltModifier:
return
if self.pattern is not None and self.pattern.is_any_selected():
self.pattern.unselect_all()
self._draw_widget.update()
return
position = QPoint(mouse_event.x(), mouse_event.y())
position = self.mapToGlobal(position)
position = self.ui.patternFrame.mapFromGlobal(position)
frame_geometry = self.ui.patternFrame.geometry()
if position.x() >= 0 and position.x() < frame_geometry.width() and position.y() >= 0 and position.y() < frame_geometry.height():
position = self._transformations.point_from_screen(position)
existing_starfish = self.pattern.get_starfish_at_position(position)
if existing_starfish is not None:
self.pattern.remove_starfish(existing_starfish)
else:
starfish_type = StarfishType(random.randint(0,1))
self.pattern.add_starfish_at_position(position, starfish_type)
self._draw_widget.update()
class FixedGridWidget(QWidget):
def __init__(self, size, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__grid_size = size
self.__pen_width = 1
self.__line_color = QColor(192, 192, 192, 255)
self.__offset = QPoint(0, 0)
# Disable the widgets to ignore all events
# Widget should not become mousegrabber
self.setDisabled(True)
def set_offset(self, offset):
"""
Sets an offset on the grid to simulate a move.
"""
self.__offset = QPoint(offset.x() % self.__grid_size,
offset.y() % self.__grid_size)
def paintEvent(self, event: QPaintEvent):
# Init painter
pen = QPen()
pen.setWidth(self.__pen_width)
pen.setColor(self.__line_color)
painter = QPainter()
painter.begin(self)
painter.setPen(pen)
# Horizontal lines
start_h = QPoint(0, self.__offset.y())
end_h = QPoint(self.width(), self.__offset.y())
distance_h = QPoint(0, self.__grid_size)
# Vertical lines
start_v = QPoint(self.__offset.x(), 0)
end_v = QPoint(self.__offset.x(), self.height())
distance_v = QPoint(self.__grid_size, 0)
while start_h.y() < self.height():
painter.drawLine(start_h, end_h)
start_h += distance_h
end_h += distance_h
while start_v.x() < self.width():
painter.drawLine(start_v, end_v)
start_v += distance_v
end_v += distance_v
painter.end()
def mouseMoveEvent(self, event):
try:
delta = QPoint(event.globalPos() - self.oldPos)
self.move(self.x() + delta.x(), self.y() + delta.y())
self.oldPos = event.globalPos()
except:
pass
def paintEvent(self, event: QPaintEvent):
# Init painter
pen = QPen()
pen.setWidth(self.__pen_width)
pen.setColor(self.__line_color)
painter = QPainter()
painter.begin(self)
painter.setPen(pen)
# Horizontal lines
start_h = QPoint(0, self.__offset.y())
end_h = QPoint(self.width(), self.__offset.y())
distance_h = QPoint(0, self.__grid_size)
# Vertical lines
start_v = QPoint(self.__offset.x(), 0)
end_v = QPoint(self.__offset.x(), self.height())
distance_v = QPoint(self.__grid_size, 0)
while start_h.y() < self.height():
painter.drawLine(start_h, end_h)
start_h += distance_h
end_h += distance_h
while start_v.x() < self.width():
painter.drawLine(start_v, end_v)
start_v += distance_v
end_v += distance_v
painter.end()
def isPointInRect(point: QPoint, rect: Tuple[QPoint, QSize]) -> bool:
"""Checking the position of a point relative to a rectangle."""
return (
rect[0].x() <= point.x() <= rect[0].x() + rect[1].width()
and rect[0].y() <= point.y() <= rect[0].y() + rect[1].height()
)
def popupAtPosition(self, parent, rect):
self.show()
if isinstance(rect, QRect):
new_pos = parent.mapToGlobal(rect.bottomRight() -
QPoint(self.width(), 0))
new_pos = QPoint(max(0, new_pos.x()), new_pos.y())
elif isinstance(rect, QPoint):
new_pos = parent.mapToGlobal(rect)
self.move(new_pos)
def _showMenu(self):
if not self._menu or self._menu.isVisible():
return
self.aboutToShowMenu.emit()
pos = QPoint()
if self._options & self._ShowMenuInsideOption:
pos = self.mapToGlobal(self.rect().bottomRight())
if QApplication.layoutDirection() == Qt.RightToLeft:
pos.setX(pos.x() - self.rect().width())
else:
pos.setX(pos.x() - self._menu.sizeHint().width())
else:
pos = self.mapToGlobal(self.rect().bottomLeft())
self._menu.popup(pos)
def extract_value(vs_frame: vs.VideoFrame, plane: int,
pos: Qt.QPoint) -> Union[int, float]:
fmt = vs_frame.format
stride = vs_frame.get_stride(plane)
if fmt.sample_type == vs.FLOAT and fmt.bytes_per_sample == 2:
ptr = ctypes.cast(
vs_frame.get_read_ptr(plane),
ctypes.POINTER(ctypes.c_char * (stride * vs_frame.height)))
offset = pos.y() * stride + pos.x() * 2
val = unpack('e', ptr.contents[offset:(offset +
2)])[0] # type: ignore
return cast(float, val)
else:
ptr = ctypes.cast(
vs_frame.get_read_ptr(plane),
ctypes.POINTER(
self.data_types[fmt.sample_type][fmt.bytes_per_sample]
* ( # type:ignore
stride * vs_frame.height)))
logical_stride = stride // fmt.bytes_per_sample
idx = pos.y() * logical_stride + pos.x()
return ptr.contents[idx] # type: ignore
def centerWidgetToParent(self, widget, parent):
'''
@brief: Very, very, very simplified QDialog.adjustPosition from qdialog.cpp
'''
if not parent or not widget:
return
p = QPoint()
parent = parent.window()
# QPoint
pp = parent.mapToGlobal(QPoint(0, 0))
p = QPoint(pp.x() + parent.width() / 2, pp.y() + parent.height() / 2)
p = QPoint(p.x() - widget.width() / 2, p.y() - widget.height() / 2 - 20)
widget.move(p)
class FixedGrid(Grid):
def __init__(self, size: int):
super().__init__()
self.__size = size
self.__offset = QPoint()
def relative_move(self, dx: int, dy: int, widget: GraphItem):
return super().relative_move(dx, dy, widget)
def get_grid_position(self, p):
# Subtract 2 for previnting flapping of widgets
return self.__offset + QPoint(
self.__size * round((p.x() - self.__offset.x() - 2) / self.__size),
self.__size * round((p.y() - self.__offset.y() - 2) / self.__size))
def set_offset(self, d):
self.__offset = QPoint(d.x() % self.__size, d.y() % self.__size)
def paintEvent(self, ev):
offset = QPoint(0, 0)
p = QPainter(self)
p.setClipRect(ev.rect())
bottom = self.rect().bottom()
if self.results:
for i, (prefix, full, text) in enumerate(self.results):
size = prefix.size()
if offset.y() + size.height() > bottom:
break
self.max_result = i
offset.setX(0)
if i in (self.current_result, self.mouse_hover_result):
p.save()
if i != self.current_result:
p.setPen(Qt.PenStyle.DotLine)
p.drawLine(offset, QPoint(self.width(), offset.y()))
p.restore()
offset.setY(offset.y() + self.MARGIN // 2)
p.drawStaticText(offset, prefix)
offset.setX(self.maxwidth + 5)
p.drawStaticText(offset, self.divider)
offset.setX(offset.x() + self.divider.size().width())
p.drawStaticText(offset, full)
offset.setY(offset.y() + size.height() + self.MARGIN // 2)
if i in (self.current_result, self.mouse_hover_result):
offset.setX(0)
p.save()
if i != self.current_result:
p.setPen(Qt.PenStyle.DotLine)
p.drawLine(offset, QPoint(self.width(), offset.y()))
p.restore()
else:
p.drawText(self.rect(), Qt.AlignmentFlag.AlignCenter,
_('No results found'))
p.end()
def paintEvent(self, ev):
offset = QPoint(0, 0)
p = QPainter(self)
p.setClipRect(ev.rect())
bottom = self.rect().bottom()
if self.results:
for i, (prefix, full, text) in enumerate(self.results):
size = prefix.size()
if offset.y() + size.height() > bottom:
break
self.max_result = i
offset.setX(0)
if i in (self.current_result, self.mouse_hover_result):
p.save()
if i != self.current_result:
p.setPen(Qt.DotLine)
p.drawLine(offset, QPoint(self.width(), offset.y()))
p.restore()
offset.setY(offset.y() + self.MARGIN // 2)
p.drawStaticText(offset, prefix)
offset.setX(self.maxwidth + 5)
p.drawStaticText(offset, self.divider)
offset.setX(offset.x() + self.divider.size().width())
p.drawStaticText(offset, full)
offset.setY(offset.y() + size.height() + self.MARGIN // 2)
if i in (self.current_result, self.mouse_hover_result):
offset.setX(0)
p.save()
if i != self.current_result:
p.setPen(Qt.DotLine)
p.drawLine(offset, QPoint(self.width(), offset.y()))
p.restore()
else:
p.drawText(self.rect(), Qt.AlignCenter, _('No results found'))
p.end()
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
def translate(self, delta: QPoint) -> None:
"""Translate camera."""
self.cam_x -= delta.x() * self.cam_z
self.cam_y -= delta.y() * self.cam_z
class PaintBoard(QLabel):
signal_right_mouse = pyqtSignal(int)
signal_draw = pyqtSignal()
def __init__(self, parent=None):
super().__init__(parent)
self.__parent = parent
self.__board = QPixmap(QSize(440, 440))
self.__board.fill(Qt.transparent)
self.__board_old = self.__board.copy()
self.__board_old_old = self.__board.copy()
self.__board_before_dots = self.__board.copy()
self.__thickness = 10 # 默认画笔粗细为10px
self.__penColor = QColor(0, 0, 0, 128)
self.__painter = QPainter()
self.__pen = QPen(self.__penColor, self.__thickness)
self.__pen_seg = QPen(QColor(0, 0, 0, 128))
self.__brush = QBrush(QColor(0, 0, 0, 128))
self.__pen.setCapStyle(Qt.RoundCap)
#self.__painter.setPen(self.__pen)
self.__lastPos = QPoint(0, 0) # 上一次鼠标位置
self.__currentPos = QPoint(0, 0) # 当前的鼠标位置
self.__points = [] # dots模式的点集
self.__mouse_pressed = False
self.__can_undo = False
self.__has_seg = False
self.__mode = 1
self.__ERASE = 0
self.__LINE = 1
self.__RECT = 2
self.__CIRCLE = 3
self.__DOTS = 4
self.__transparent = False
self.__trans_board = self.__board.copy()
self.__trans_board.fill(Qt.transparent)
@staticmethod
def dist(p1, p2):
return math.hypot(p1.x() - p2.x(), p1.y() - p2.y())
# Each time paintEvent is called it clean the space where it is going to draw.
# So it does not save memory of the previous drawings,
# A simple solution is to first paint a QPixmap to store what you have painted.
# And then paint the widget with that QPixmap.
def set_trans(self, trans):
self.__transparent = trans
self.update()
def is_trans(self):
return self.__transparent
def paintEvent(self, paint_event): # 把board绘制到界面上
self.__painter.begin(self)
if not self.__transparent:
self.__painter.drawPixmap(0, 0, self.__board)
else:
self.__painter.drawPixmap(0, 0, self.__trans_board) #结果图关闭mask
self.__painter.end()
def mousePressEvent(self, mouse_event):
if mouse_event.button() == Qt.LeftButton:
self.__mouse_pressed = True
self.__board_old_old = self.__board_old.copy()
self.__board_old = self.__board.copy()
self.__currentPos = mouse_event.pos()
self.__lastPos = self.__currentPos
if self.__mode == self.__DOTS:
if len(self.__points) == 0:
self.__board_before_dots = self.__board.copy()
self.__parent.childAt(740, 0).setEnabled(False)
self.__parent.childAt(840, 0).setEnabled(False)
self.__parent.childAt(370, 0).setEnabled(False)
self.__parent.childAt(300, 610).setEnabled(False)
if len(self.__points) > 0:
print(
self.dist(
self.__points[0],
QPoint(self.__currentPos.x(),
self.__currentPos.y())))
if len(self.__points) > 2 and \
self.dist(self.__points[0], QPoint(self.__currentPos.x(), self.__currentPos.y())) < 5:
self.__board = self.__board_before_dots.copy()
self.__painter.begin(self.__board)
if self.__ERASE:
self.__painter.setCompositionMode(
QPainter.CompositionMode_Clear)
else:
self.__painter.setCompositionMode(
QPainter.CompositionMode_Source)
self.__painter.setPen(Qt.NoPen)
self.__painter.setBrush(self.__brush)
self.__painter.drawPolygon(QPolygon(self.__points))
self.signal_draw.emit()
self.__painter.end()
self.__points.clear()
self.__parent.childAt(740, 0).setEnabled(True)
self.__parent.childAt(840, 0).setEnabled(True)
self.__parent.childAt(370, 0).setEnabled(True)
self.__parent.childAt(300, 610).setEnabled(True)
self.update()
else:
self.__points.append(
QPoint(self.__currentPos.x(), self.__currentPos.y()))
if not (self.__mode == self.__DOTS and len(self.__points) == 1):
self.__can_undo = True
self.__parent.childAt(70, 610).setEnabled(True)
else:
self.__can_undo = False
self.__parent.childAt(70, 610).setEnabled(False)
def mouseMoveEvent(self, mouse_event): # 把线绘制到board上
self.__currentPos = mouse_event.pos()
if self.__mode != self.__LINE:
if len(self.__points) > 0:
self.__board = self.__board_old.copy()
elif not self.__mode == self.__DOTS:
if self.__mouse_pressed:
self.__board = self.__board_old.copy()
self.__painter.begin(self.__board)
self.__painter.setPen(self.__pen)
if self.__ERASE:
self.__painter.setCompositionMode(QPainter.CompositionMode_Clear)
else:
self.__painter.setCompositionMode(QPainter.CompositionMode_Source)
if self.__mode == self.__LINE:
if self.__mouse_pressed:
self.__painter.drawLine(self.__lastPos, self.__currentPos)
self.signal_draw.emit()
elif self.__mode == self.__RECT:
self.__painter.setPen(Qt.NoPen)
self.__painter.setBrush(self.__brush)
if self.__mouse_pressed:
self.__painter.drawRect(
self.__lastPos.x(), self.__lastPos.y(),
(self.__currentPos.x() - self.__lastPos.x()),
(self.__currentPos.y() - self.__lastPos.y()))
self.signal_draw.emit()
elif self.__mode == self.__CIRCLE:
self.__painter.setPen(Qt.NoPen)
self.__painter.setBrush(self.__brush)
if self.__mouse_pressed:
self.__painter.drawEllipse(
self.__lastPos.x(), self.__lastPos.y(),
(self.__currentPos.x() - self.__lastPos.x()),
(self.__currentPos.y() - self.__lastPos.y()))
self.signal_draw.emit()
elif self.__mode == self.__DOTS:
if len(self.__points) > 0:
self.__painter.setCompositionMode(
QPainter.CompositionMode_Source)
self.__painter.setPen(QPen(self.__pen_seg.color(), 1))
self.__painter.drawLine(self.__points[-1], self.__currentPos)
self.signal_draw.emit()
self.__painter.end()
if self.__mode == self.__LINE:
self.__lastPos = self.__currentPos
self.update() # 触发paintEvent
def mouseDoubleClickEvent(self, mouse_event):
if mouse_event.button() == Qt.LeftButton:
if not self.__mode == self.__DOTS:
if self.__has_seg:
x = mouse_event.pos().x()
y = mouse_event.pos().y()
value = self.segment[y][x] # 注意这里x和y要反过来
self.__painter.begin(self.__board)
self.paint_segment(value, x, y)
self.__painter.end()
self.signal_draw.emit()
self.update() # 触发paintEvent
def mouseReleaseEvent(self, mouse_event):
if mouse_event.button() == Qt.LeftButton:
self.__mouse_pressed = False
if mouse_event.button() == Qt.RightButton:
self.signal_right_mouse.emit(1 - self.__ERASE)
return
def undo(self):
if self.__can_undo:
if self.__mode != self.__DOTS:
self.__board = self.__board_old.copy()
else:
if len(self.__points) == 0:
self.__board = self.__board_before_dots.copy()
else:
self.__points.pop()
self.__board = self.__board_old_old.copy()
self.__board_old = self.__board_old_old.copy()
self.signal_draw.emit()
self.update()
self.__can_undo = False
self.__parent.childAt(70, 610).setEnabled(False)
def update_segment(self, seg):
self.segment = seg
self.__parent.childAt(1040, 0).setEnabled(False)
self.__has_seg = True
def set_board(self, x, y):
self.__board = self.__board.scaled(x, y)
def update_board(self, board):
self.__board = board
self.update()
def paint_segment(self, value, x, y):
has_painted = np.zeros(self.segment.shape, dtype=np.uint8)
point_stack = [(x, y)]
while len(point_stack) > 0:
point = point_stack.pop()
x = point[0]
y = point[1]
self.__painter.setPen(self.__pen_seg)
if self.__ERASE:
self.__painter.setCompositionMode(
QPainter.CompositionMode_Clear)
else:
self.__painter.setCompositionMode(
QPainter.CompositionMode_Source)
self.__painter.drawPoint(x, y)
has_painted[y][x] = 1
if x + 1 < self.segment.shape[1] and has_painted[y][
x + 1] == 0 and value == self.segment[y][x + 1]:
point_stack.append((x + 1, y))
if x - 1 >= 0 and has_painted[y][
x - 1] == 0 and value == self.segment[y][x - 1]:
point_stack.append((x - 1, y))
if y + 1 < self.segment.shape[0] and has_painted[
y + 1][x] == 0 and value == self.segment[y + 1][x]:
point_stack.append((x, y + 1))
if y - 1 >= 0 and has_painted[
y - 1][x] == 0 and value == self.segment[y - 1][x]:
point_stack.append((x, y - 1))
def Thanos(self, label):
if len(label) == 0:
return False
image = self.__board.copy()
image.fill(Qt.transparent)
pixels = image.toImage()
s = pixels.bits().asstring(pixels.width() * pixels.height() * 4)
arr = np.fromstring(s, dtype=np.uint8).reshape(
(pixels.height(), pixels.width(), 4))
np.set_printoptions(threshold=sys.maxsize)
mask = arr[..., 3]
for l in label:
mask[self.segment == l] = 255
expand_mask(mask, 5)
#Image.fromarray(np.uint8(mask)).save('mask_10.jpg')
return mask
def set_seg(self):
self.__has_seg = False
def set_pen(self, value):
self.__pen.setWidth(value)
def pen_black(self):
self.__pen.setColor(QColor(0, 0, 0, 128))
def pen_white(self):
self.__pen.setColor(QColor(255, 255, 255, 128))
def geo_black(self):
self.__pen_seg.setColor(QColor(0, 0, 0, 128))
self.__brush = QBrush(QColor(0, 0, 0, 128))
def geo_white(self):
self.__pen_seg.setColor(QColor(255, 255, 255, 128))
self.__brush = QBrush(QColor(255, 255, 255, 128))
def switch_mode(self):
self.__ERASE = 1 - self.__ERASE
def set_mode(self, mode):
self.__ERASE = mode
def tool_pen(self):
self.__mode = self.__LINE
def tool_rect(self):
self.__mode = self.__RECT
def tool_circle(self):
self.__mode = self.__CIRCLE
def tool_dots(self):
self.__mode = self.__DOTS
def clear_board(self):
self.__board.fill(Qt.transparent)
self.__board_old = self.__board.copy()
self.__board_before_dots = self.__board.copy()
self.__board_old_old = self.__board.copy()
self.__parent.childAt(70, 610).setEnabled(False)
self.signal_draw.emit()
self.update()
def save(self):
# save_path = QFileDialog.getSaveFileName(self, 'Save Your Paint', '.\\', '*.jpg')
save_path = 'D:/test.png', '*.png'
print(save_path)
if save_path[0] == "":
print("Save cancel")
return
image = self.__board
pixels = image.toImage()
s = pixels.bits().asstring(pixels.width() * pixels.height() * 4)
arr = np.fromstring(s, dtype=np.uint8).reshape(
(pixels.height(), pixels.width(), 4))
np.set_printoptions(threshold=sys.maxsize)
mask = arr[..., 3]
print(mask)
# qimage2numpy(pixels)
# Pixels can only be accessed through QPainter functions or by converting the QPixmap to a QImage.
image.save(save_path[0])
def get_mask(self):
image = self.__board
pixels = image.toImage()
s = pixels.bits().asstring(pixels.width() * pixels.height() * 4)
arr = np.fromstring(s, dtype=np.uint8).reshape(
(pixels.height(), pixels.width(), 4))
np.set_printoptions(threshold=sys.maxsize)
mask = arr[..., 3] # 取alpha通道，就是不透明度
mask[mask > 0] = 255
return mask
def get_board(self):
return self.__board.copy()
def test(self):
# self.pix = QPixmap("road.jpg")
self.__painter.begin(self.__board)
for i in range(301):
for j in range(301):
self.__painter.drawPoint(i, j)
self.__painter.end()
self.update()
