def paintEvent(self, event): """ Handles the LEDs redraw process :param event: """ super().paintEvent(event) top_color = self.config.get('colors', 'led_top_row') bottom_color = self.config.get('colors', 'led_bottom_row') # LEDs painter = QPainter(self) pen = QPen() pen.setWidth(10) pinColor = ["black", "red", "grey", "yellow"] led_dico = self.digirule.get_led_positions_dic() for led in led_dico: if led_dico[led] == "pin0Led" or led_dico[led] == "pin1Led": # pin Leds can be of 4 different colors pen.setColor(QColor(pinColor[self.led_states[led_dico[led]]])) elif self.led_states[led_dico[led]]: # LED active color pen.setColor( QColor(top_color if "top" in led_dico[led] else bottom_color)) else: # LED inactive color pen.setColor(QColor("black")) painter.setPen(pen) painter.drawPoint(QPoint(led[0], led[1]))
def redraw(self): """ Re-draws the buttons. May be called as initialization method too. """ # Pixmap that contains the painter and the DR canvas = QPixmap("assets/" + self.digirule.get_img_name()) self.setPixmap(canvas) painter = QPainter(self.pixmap( )) # Create a painter in which buttons and LEDs are drawn translate_matrix = QMatrix() offset_scale = self.digirule.get_scale_offset() translate_matrix.scale(offset_scale[0], offset_scale[1]) painter.setMatrix(translate_matrix) # Drawing pen = QPen() pen.setWidth(self.digirule.get_buttons_width()) pen.setColor(QColor(0, 0, 0, 0)) # Buttons color painter.setPen(pen) # Buttons for btn in self.digirule.get_buttons_positions_dic(): painter.drawPoint(QPoint(btn[0], btn[1])) pen.setWidth(2) painter.setPen(pen) for btn in self.digirule.get_special_buttons_rects_dic(): # Draw rectangle given the top-left and bottom-right corners coordinates painter.drawRect(self._build_rect(btn))
def paintEvent(self, event): """Event""" rec = event.rect() painter = QPainter() painter.begin(self) if not self.start_points: painter.fillRect(rec, QColor(0, 0, 0, 100)) self.update_start_points(rec) # make mypy happy assert isinstance(self.start_points, list) if not self.last_point: pt = random.choice(self.start_points) else: rp = random.choice(self.start_points) pt = QPoint( (self.last_point.x() + rp.x()) / 2, (self.last_point.y() + rp.y()) / 2, ) self.last_point = pt painter.setPen(QPen(self.color, 0.8)) painter.drawPoint(pt) painter.end() # start next update self.update()
def draw_mask_point(self, point, pen_size: int = None): if pen_size is None: pen_size = self.tools.get_size() painter = QPainter(self.image_label.pixmap()) painter.setPen( QPen(self.tools.mask_color, pen_size, Qt.SolidLine, Qt.SquareCap, Qt.RoundJoin)) painter.drawPoint(point)
def paint(self,painter:QPainter,view:QPaintDevice): painter.begin(view) self.setTool(painter) x=linearTrans(self.x,self.width,view.width()) y=linearTrans(self.y,self.height,view.height()) painter.drawPoint(x,y) print("%s:(%d,%d)"%(self.type,x,y)) painter.end() pass
def assert_equal(self): __tracebackhide__ = True self.end() self.different_pixels = 0 actual_image: QImage = self.actual.device().toImage() expected_image: QImage = self.expected.device().toImage() diff_pixmap = QPixmap(actual_image.width(), actual_image.height()) diff = QPainter(diff_pixmap) try: white = QColor('white') diff.fillRect(0, 0, actual_image.width(), actual_image.height(), white) for x in range(actual_image.width()): for y in range(actual_image.height()): actual_colour = actual_image.pixelColor(x, y) expected_colour = expected_image.pixelColor(x, y) diff.setPen( self.diff_colour(actual_colour, expected_colour, x, y)) diff.drawPoint(x, y) finally: diff.end() diff_image: QImage = diff.device().toImage() display_diff(actual_image, diff_image, expected_image, self.different_pixels) if self.different_pixels == 0: return actual_image.save(str(self.work_dir / (self.name + '_actual.png'))) expected_image.save(str(self.work_dir / (self.name + '_expected.png'))) diff_path = self.work_dir / (self.name + '_diff.png') is_saved = diff_image.save(str(diff_path)) diff_width = self.diff_max_x - self.diff_min_x + 1 diff_height = self.diff_max_y - self.diff_min_y + 1 diff_section = QImage(diff_width, diff_height, QImage.Format_RGB32) diff_section_painter = QPainter(diff_section) try: diff_section_painter.drawPixmap(0, 0, diff_width, diff_height, QPixmap.fromImage(diff_image), self.diff_min_x, self.diff_min_y, diff_width, diff_height) finally: diff_section_painter.end() # To see an image dumped in the Travis CI log, copy the text from the # log, and paste it in test_pixmap_differ.test_decode_image. print(f'Encoded image of differing section ' f'({self.diff_min_x}, {self.diff_min_y}) - ' f'({self.diff_max_x}, {self.diff_max_y}):') print(encode_image(diff_section)) message = f'Found {self.different_pixels} different pixels, ' message += f'see' if is_saved else 'could not write' message += f' {diff_path.relative_to(Path(__file__).parent.parent)}.' assert self.different_pixels == 0, message
def setup(self): if not self.is_set: _edge = max([PartyConst.WIDTH, PartyConst.HEIGHT]) self._stars = np.random.randint(low=0, high=_edge, size=((_edge // 250)**2, 2)) self._pen_link = QPen(QColor('#351c75'), 2, Qt.SolidLine) self._lines = [] min_dist = 100 for _star in self._stars: for _sub_star in self._stars: if 0 < np.linalg.norm(_star - _sub_star) < min_dist: self._lines.append((_star, _sub_star)) _edge = max([PartyConst.WIDTH, PartyConst.HEIGHT]) _center = QPoint(self._galaxy.width() // 2, self._galaxy.height() // 2) _gradient = QRadialGradient(_center, _edge // 2) _gradient.setColorAt(1, QColor('#20124d')) _gradient.setColorAt(0, QColor('#351c75')) painter = QPainter(self._galaxy) painter.fillRect(0, 0, _edge, _edge, _gradient) painter.setPen(self._pen_link) for _xy1, _xy2 in self._lines: _xy1, _xy2 = QPoint(*_xy1), QPoint(*_xy2) painter.drawLine(_xy1, _xy2) _star_pens = [ QPen(QColor('#ffffff'), _size, Qt.SolidLine) for _size in [1, 2, 3, 4] ] for _i, (_x, _y) in enumerate(self._stars): _xy = QPoint(_x, _y) painter.setPen(_star_pens[_i % len(_star_pens)]) painter.drawPoint(_xy) painter.end() self._galaxy.save(IMAGE_GALAXY_PATH) self.is_set = True
def paint(self, painter: QPainter, model: ShipModel = None): assert self.is_set, 'Painter is not set' # Draw ship if model.is_alive: _ship = self._ship_alive else: _ship = self._ship_dead _pixmap = _ship.transformed(model.transform, mode=Qt.SmoothTransformation) _center_ship = self.transform(model.x - _pixmap.width() / 2, model.y + _pixmap.height() / 2, is_point=True) if 0 <= _center_ship.x() <= self.parent.width( ) and 0 <= _center_ship.y() <= self.parent.height(): painter.drawPixmap(_center_ship, _pixmap) # Draw life bar _center_bar = self.transform(model.x - self._life_bar_xy[0], model.y + self._life_bar_xy[1], is_point=True) painter.setPen(QPen(QColor(255, 0, 0), 0, Qt.NoPen)) painter.setBrush(QBrush(QColor(255, 0, 0))) painter.drawRect(_center_bar.x(), _center_bar.y(), self._life_bar_width, 5) painter.setBrush(QBrush(QColor(0, 255, 0))) painter.drawRect(_center_bar.x(), _center_bar.y(), int(self._life_bar_width * model.life), 5) painter.setPen(QPen(QColor(*model.color), 5, Qt.SolidLine)) _center_title = self.transform(model.x - 100, model.y + 70, is_point=True) painter.setFont( QFont('Open Sans', weight=QFont.Normal, pointSize=8)) painter.drawText( QRect(_center_title.x(), _center_title.y(), 200, 25), Qt.AlignHCenter | Qt.AlignTop, '<{}>'.format(model.name)) painter.setBrush(QBrush(QColor(*model.color))) _center_point = self.transform(model.x, model.y, is_point=True) painter.drawPoint(_center_point) else: _xy = QPoint(_center_ship) if _center_ship.x() < 0: _xy.setX(0) if self.parent.width() < _center_ship.x(): _xy.setX(self.parent.width()) if _center_ship.y() < 0: _xy.setY(0) if self.parent.height() < _center_ship.y(): _xy.setY(self.parent.height()) painter.setPen(QPen(QColor(0, 0, 0), 30, Qt.SolidLine, Qt.RoundCap)) painter.drawPoint(_xy) painter.setPen( QPen(QColor(*model.color), 25, Qt.SolidLine, Qt.RoundCap)) painter.drawPoint(_xy)
def paintEvent(self, QPaintEvent): painter = QPainter() painter.begin(self) painter.setPen(Qt.NoPen) painter.fillRect(self.rect(), QColor(190, 190, 190, 255)) if self.label_img: if self.mouse_press_flag and self.mouse_pos: pp = QPainter(self.mask_img) if self.eraser_painting_model: pp.setPen( QPen(self.eraser_color, self.eraser_pixle_size, Qt.SolidLine, Qt.RoundCap, Qt.BevelJoin)) else: pp.setPen( QPen(self.brush_color, self.brush_pixle_size, Qt.SolidLine, Qt.RoundCap, Qt.BevelJoin)) pp.drawPoint(self.mouse_pos - self.img_rect.topLeft()) result_pixmap = self.join_pixmap(self.label_img, self.mask_img) painter.drawPixmap(self.img_rect, result_pixmap) painter.end()
def paintEvent(self, paintEvent: QPaintEvent): pen = QPen() pen.setJoinStyle(Qt.RoundJoin) pen.setCapStyle(Qt.RoundCap) painter = QPainter(self) painter.translate(self.paintOffset) painter.setBackgroundMode(Qt.TransparentMode) painter.setRenderHint(QPainter.Antialiasing) if self.nodes is not None: painted = set() def paintNode(node): nonlocal painter, painted if node in painted: return painted.add(node) for link in node.links: if link not in painted: painter.drawLine(node.point, link.point) paintNode(link) color = self.palette().color(QPalette.Dark) pen.setColor(color) pen.setWidth(0.50 * self.paintStep) painter.setPen(pen) for node in self.nodes.values(): if paintEvent.region().contains(node.point): paintNode(node) if self.startNode is not None: color = self.palette().color(QPalette.Dark) pen.setColor(color) pen.setWidth(0.75 * self.paintStep) painter.setPen(pen) if paintEvent.region().contains(self.startNode.point): painter.drawPoint(self.startNode.point) if self.finishNode is not None and paintEvent.region().contains(self.finishNode.point): color = self.palette().color(QPalette.Dark).darker(120) pen.setColor(color) pen.setWidth(0.75 * self.paintStep) painter.setPen(pen) painter.drawPoint(self.finishNode.point) if self.player is not None: color = self.palette().color(QPalette.Highlight) color.setAlpha(196) pen.setColor(color) pen.setWidth(0.90 * self.paintStep) painter.setPen(pen) painter.drawPoint(self.player) del painter, pen
class ImageSegmenterView(QGraphicsView): photoClicked = Signal(QPoint) def __init__(self, parent): super(ImageSegmenterView, self).__init__(parent) self._zoom = 0 self.empty = True self._scene = QGraphicsScene(self) self._photo = QGraphicsPixmapItem() self.image_hidden = False self._seglayer = QGraphicsPixmapItem() self._seglayer.setOpacity(0.5) self._scene.addItem(self._photo) self._scene.addItem(self._seglayer) self.setScene(self._scene) self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse) self.setResizeAnchor(QGraphicsView.AnchorUnderMouse) # self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) # self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) self.setBackgroundBrush(QBrush(QtCore.Qt.darkGray)) self.setFrameShape(QFrame.NoFrame) self.seg_image = None self.start = False self.prev_point = None self.painter = None self.segmenter_pen = QPen(QtCore.Qt.green, 30, QtCore.Qt.SolidLine) self.segmenter_pen.setCapStyle(QtCore.Qt.RoundCap) self.segmenter_pen.setJoinStyle(QtCore.Qt.RoundJoin) self.erase = False self.changed = False self.history = collections.deque(maxlen=10) self.future = collections.deque(maxlen=10) def hasPhoto(self): return not self.empty def fitInView(self, scale=True): rect = QtCore.QRectF(self._photo.pixmap().rect()) if not rect.isNull(): self.setSceneRect(rect) if self.hasPhoto(): unity = self.transform().mapRect(QtCore.QRectF(0, 0, 1, 1)) self.scale(1 / unity.width(), 1 / unity.height()) viewrect = self.viewport().rect() scenerect = self.transform().mapRect(rect) factor = min(viewrect.width() / scenerect.width(), viewrect.height() / scenerect.height()) self.scale(factor, factor) self._zoom = 0 def setPhoto(self, pixmap=None): self._zoom = 0 if pixmap and not pixmap.isNull(): self.empty = False self.changed = False self._photo.setPixmap(pixmap) self.seg_image = QImage(pixmap.width(), pixmap.height(), QImage.Format_ARGB32_Premultiplied) self.seg_image.fill(QtCore.Qt.transparent) self._seglayer.setPixmap(QPixmap.fromImage(self.seg_image)) else: self._empty = True self._photo.setPixmap(QPixmap()) self.fitInView() def save_state(self): if self.future is not None: while len(self.future) > 0: present = self.future.pop() del present if self.seg_image is not None: self.history.append(self.seg_image.copy()) def clear_history(self): while len(self.history) > 0: present = self.history.pop() del present def undo(self): if len(self.history) > 0: self.future.append(self.seg_image) present = self.history.pop() self.seg_image = present self._seglayer.setPixmap(QPixmap.fromImage(self.seg_image)) def redo(self): if len(self.future) > 0: self.history.append(self.seg_image) present = self.future.pop() self.seg_image = present self._seglayer.setPixmap(QPixmap.fromImage(self.seg_image)) def setSegLayer(self, pixmap=None): if not self._photo.pixmap().isNull(): self.save_state() self.seg_image = QImage(pixmap.toImage()) self._seglayer.setPixmap(QPixmap.fromImage(self.seg_image)) def resetSegLayer(self): if not self._photo.pixmap().isNull(): self.changed = True self.save_state() del self.seg_image self.seg_image = QImage(self._photo.pixmap().width(), self._photo.pixmap().height(), QImage.Format_ARGB32_Premultiplied) self.seg_image.fill(QtCore.Qt.transparent) self._seglayer.setPixmap(QPixmap.fromImage(self.seg_image)) def wheelEvent(self, event): if self.hasPhoto() and not self.start: if event.angleDelta().y() > 0: factor = 1.25 self._zoom += 1 else: factor = 0.8 self._zoom -= 1 if self._zoom > 0: self.scale(factor, factor) elif self._zoom == 0: self.fitInView() else: self._zoom = 0 def mousePressEvent(self, event): if not self._photo.pixmap().isNull(): if event.button() == QtCore.Qt.LeftButton: self.save_state() self.start = True self.painter = QPainter(self.seg_image) if self.erase: self.painter.setCompositionMode( QPainter.CompositionMode_Clear) self.painter.setPen(self.segmenter_pen) self.paint_point(event.pos()) elif event.button() == QtCore.Qt.RightButton: if not self._photo.pixmap().isNull(): self.setDragMode(QGraphicsView.ScrollHandDrag) self.scroll_origin = self.mapToScene(event.pos()) # if self._photo.isUnderMouse(): # self.photoClicked.emit(self.mapToScene(event.pos()).toPoint()) super(ImageSegmenterView, self).mousePressEvent(event) def mouseMoveEvent(self, event): if not self._photo.pixmap().isNull(): if self.start: self.paint_point(event.pos()) if event.buttons() & QtCore.Qt.RightButton: newpoint = self.mapToScene(event.pos()) translation = newpoint - self.scroll_origin self.translate(translation.x(), translation.y()) self.scroll_origin = self.mapToScene(event.pos()) super(ImageSegmenterView, self).mouseMoveEvent(event) def mouseReleaseEvent(self, event): if not self._photo.pixmap().isNull(): if self.start: self.start = False self.prev_point = None self.painter.end() if self.dragMode() == QGraphicsView.ScrollHandDrag: self.setDragMode(QGraphicsView.NoDrag) def paint_point(self, pos): self.changed = True pos = self.mapToScene(pos).toPoint() if self.prev_point is not None: self.painter.drawLine(self.prev_point, pos) else: self.painter.drawPoint(pos) self.prev_point = pos self._seglayer.setPixmap(QPixmap.fromImage(self.seg_image)) def set_foreground(self): self.erase = False self.segmenter_pen.setColor(QtCore.Qt.green) def set_possible_foreground(self): self.erase = False self.segmenter_pen.setColor(QtCore.Qt.blue) def set_possible_background(self): self.erase = True self.segmenter_pen.setColor(QtCore.Qt.transparent) def set_background(self): self.erase = False self.segmenter_pen.setColor(QtCore.Qt.red) def set_pen_size(self, size): self.segmenter_pen.setWidth(size) def set_opacity(self, value): self._seglayer.setOpacity(value / 100) def hide_image(self): if self.image_hidden: self._photo.setOpacity(1) self.image_hidden = False else: self._photo.setOpacity(0) self.image_hidden = True
def draw_mini_map(self, painter, is_full=False): _pixmap_minimap = QPixmap( QSize(min([self.width(), self.height()]), min([self.width(), self.height()]))) if is_full else QPixmap( QSize(350, 350)) if is_full: _p_origin = QPoint((self.width() - _pixmap_minimap.width()) // 2, (self.height() - _pixmap_minimap.height()) // 2) else: _p_origin = QPoint(self.width() - _pixmap_minimap.width(), self.height() - _pixmap_minimap.height()) _pixmap_minimap.fill(QColor('#00284d')) # DRAW DEAD ZONE _dz_radius = self.controller.get_dead_zone_radius() _xy = QPoint(*self.controller.get_dead_zone_center().tolist()) # GET MOBILE OBJECTS _model_ships = self.controller.get_data_from_players(enemy_only=False) _model_bolts = self.controller.get_data_from_bolts() _model_asteroids = self.controller.get_data_from_asteroids() # SET MINI MAP _w_ratio = _pixmap_minimap.width() / (PartyConst.WIDTH * 1.25) _h_ratio = _pixmap_minimap.height() / (PartyConst.HEIGHT * 1.25) _minimap_painter = QPainter(_pixmap_minimap) _minimap_painter.setOpacity(1) for _ship in _model_ships: _w = _ship.radius * _w_ratio if _w < 3: _w = 3 _x, _y = int( _ship.x * _w_ratio) + _pixmap_minimap.width() // 2, int( _ship.y * _h_ratio) + _pixmap_minimap.height() // 2 if _ship.is_alive: _factor_1 = (time.time() * 2) % 2 _factor_2 = (time.time() * 2 + .5) % 2 _minimap_painter.setPen( QPen(QColor('#ffffff'), 1, Qt.SolidLine)) _minimap_painter.setOpacity(1 - _factor_1) _minimap_painter.drawEllipse(QPoint(_x, _y), int(20 * _factor_1), int(20 * _factor_1)) _minimap_painter.setOpacity(1 - _factor_2) _minimap_painter.drawEllipse(QPoint(_x, _y), int(20 * _factor_2), int(20 * _factor_2)) _minimap_painter.setPen( QPen(QColor(*_ship.color), _w, Qt.SolidLine)) _minimap_painter.setOpacity(1) _minimap_painter.drawPoint(_x, _y) for _astroid in _model_asteroids: _w = _astroid.radius * _w_ratio if _w < 5: _w = 5 _pen = QPen(QColor('#ffb86c'), _w, Qt.SolidLine) _pen.setCapStyle(Qt.RoundCap) _minimap_painter.setPen(_pen) _x, _y = int( _astroid.x * _w_ratio) + _pixmap_minimap.width() // 2, int( _astroid.y * _h_ratio) + _pixmap_minimap.height() // 2 _minimap_painter.drawPoint(_x, _y) for _bolt in _model_bolts: _w = _bolt.radius * _w_ratio if _w < 1: _w = 1 _minimap_painter.setPen(QPen(QColor('#ff5555'), _w, Qt.SolidLine)) _x, _y = int( _bolt.x * _w_ratio) + _pixmap_minimap.width() // 2, int( _bolt.y * _h_ratio) + _pixmap_minimap.height() // 2 _minimap_painter.drawPoint(_x, _y) _xy.setX(_xy.x() * _w_ratio + _pixmap_minimap.width() // 2) _xy.setY(_xy.y() * _h_ratio + _pixmap_minimap.height() // 2) _minimap_painter.setPen(QPen(QColor('#8be9fd'), 3, Qt.SolidLine)) _minimap_painter.drawEllipse(_xy, _dz_radius * _w_ratio, _dz_radius * _h_ratio) if not is_full: _minimap_painter.setPen(QPen(QColor('#ffffff'), 1, Qt.SolidLine)) _x = -self.camera_pst.x() * _w_ratio + _pixmap_minimap.width() // 2 _y = self.camera_pst.y() * _h_ratio + _pixmap_minimap.height() // 2 _w = self.width() * _w_ratio _h = self.height() * _h_ratio _minimap_painter.drawRect(_x, _y - _h, _w, _h) _minimap_painter.end() _pixmap_minimap = _pixmap_minimap.transformed(QTransform().scale( 1, -1)) painter.setOpacity(1 if is_full else .75) painter.drawPixmap(_p_origin, _pixmap_minimap)
class QCanvas(QLabel): def __init__(self, parent: QWidget, window: MainWindow): super().__init__(parent) self.pWindow = window self.strokeX = [] self.strokeY = [] self.strokeT = [] self.timing = QTime() self.timing.start() self.paused = 0 self.painter = QPainter() self.setStyleSheet("background-color: white;") """ EVENT: MOUSE CLICK/PRESS """ def mousePressEvent(self, event: QMouseEvent) -> None: self.timing.restart() self.strokeX.append(list()) self.strokeY.append(list()) self.strokeT.append(list()) self.strokeX[-1].append(event.x()) self.strokeY[-1].append(event.y()) self.strokeT[-1].append(self.paused) return super().mousePressEvent(event) """ EVENT: MOUSE MOVE WHILE PRESSED """ def mouseMoveEvent(self, event: QMouseEvent) -> None: if event.x() > 0 and event.y() > 0 and event.x() <= self.width() and event.y() <= self.height(): # IF DRAWING IS NOT JUST A MERE POINT... if len(self.strokeT[-1]) == 1: self.timing.restart() self.paused += 1 self.strokeX[-1].append(event.x()) self.strokeY[-1].append(event.y()) self.strokeT[-1].append(self.timing.elapsed() + self.paused) else: return return super().mouseMoveEvent(event) """ EVENT: MOUSE RELEASE """ def mouseReleaseEvent(self, event: QMouseEvent) -> None: # TO ABLE TO RECOGNIZE POINTS AS PART OF THE DRAWING... if len(self.strokeT[-1]) == 1: self.paused += 1 # OTHERWISE, CHECKPOINTS THE MILLISECONDS AS FOLLOWS. else: self.paused += (self.timing.elapsed() + 1) return super().mouseReleaseEvent(event) """ EVENT: UPDATE PAINT => Beware, every time paintEvent updates removes previous drawings. Therefore, store the data of previous drawing to prevent being erased. """ def paintEvent(self, event: QPaintEvent) -> None: pen = QPen() pen.setWidth(4) pen.setColor(Qt.color1) self.painter.begin(self) self.painter.setPen(pen) if len(self.strokeX) != 0: for stroke in range(len(self.strokeX)): if len(self.strokeX[stroke]) == 1: self.painter.drawPoint(self.strokeX[stroke][0], self.strokeY[stroke][0]) else: for index in range(len(self.strokeX[stroke]) - 1): self.painter.drawLine(self.strokeX[stroke][index], self.strokeY[stroke][index], self.strokeX[stroke][index+1], self.strokeY[stroke][index+1]) self.painter.end() self.update() return super().paintEvent(event) """ EVENT: UPON SHOWN """ def showEvent(self, event: QShowEvent) -> None: self.blankCanvas() return super().showEvent(event) """ METHOD: CREATE CANVAS """ def blankCanvas(self) -> None: margin = self.parentWidget().layout().margin() width = self.topLevelWidget().width() height = self.topLevelWidget().height() for index in range(self.parentWidget().layout().count()): if index != self.parentWidget().layout().indexOf(self): height -= (self.parentWidget().layout().itemAt(index).widget().height() + margin * 2) canvas = QBitmap(width - margin * 2, height) canvas.clear() self.setPixmap(canvas) self.update() """ METHOD: RESET CANVAS """ def resetCanvas(self) -> None: self.strokeX = [] self.strokeY = [] self.strokeT = [] self.paused = 0 self.blankCanvas() """ METHOD: UNDO CANVAS """ def undoCanvas(self) -> None: try: self.paused = self.strokeT[-1][0] self.strokeX.pop() self.strokeY.pop() self.strokeT.pop() except IndexError: print("The canvas is completely empty!") self.blankCanvas()