Exemple #1
0
    def update_screen(self) -> None:
        use_live_screen = (
            self.live_screen_checkbox.checkState() == Qt.CheckState.Checked)
        is_powered_on = self.power_checkbox.checkState(
        ) == Qt.CheckState.Checked
        image_display = (self.image_display_on
                         if is_powered_on else self.image_display_off)
        result = QPixmap(image_display.size())
        result.fill(Qt.transparent)
        painter = QPainter(result)
        painter.drawPixmap(QPoint(0, 0), image_display)

        if is_powered_on:
            screenshot = get_screenshot(
            ) if use_live_screen else self.screenshot
            screenshot = screenshot.scaled(800, 800, Qt.KeepAspectRatio,
                                           Qt.SmoothTransformation)
            screenshot = screenshot.copy(QRect(0, 0, 800, 480 * 0.94))
            offset_x = (image_display.size().width() -
                        screenshot.size().width()) / 2
            offset_y = (image_display.size().height() -
                        screenshot.size().height()) / 2
            painter.setOpacity(self.backlight.brightness / 100)
            painter.drawPixmap(QPoint(offset_x, offset_y), screenshot)

        painter.end()
        result = result.scaled(600, 600, Qt.KeepAspectRatio,
                               Qt.SmoothTransformation)
        self.screen_image.setPixmap(result)
Exemple #2
0
 def merge_with_layer_immediately_below(self):
     """
     Merges a layer with the next lower visible layer. Does nothing
     if mode is preview or the target layer is an adjustment layer.
     """
     if not hasattr(self, 'inputImg'):
         return
     ind = self.getLowerVisibleStackIndex()
     if ind < 0:
         # no visible layer found
         return
     target = self.parentImage.layersStack[ind]
     if hasattr(target, 'inputImg') or self.parentImage.useThumb:
         info = "Uncheck Preview first" if self.parentImage.useThumb else "Target layer must be background or image"
         dlgWarn("Cannot Merge layers", info=info)
         return
     # update stack
     self.parentImage.layersStack[0].applyToStack()
     # merge
     # target.setImage(self)
     qp = QPainter(target)
     qp.setCompositionMode(self.compositionMode)
     qp.setOpacity(self.opacity)
     qp.drawImage(QRect(0, 0, self.width(), self.height()), self)
     target.updatePixmap()
     self.parentImage.layerView.clear(delete=False)
     currentIndex = self.getStackIndex()
     self.parentImage.activeLayerIndex = ind
     self.parentImage.layersStack.pop(currentIndex)
     self.parentImage.layerView.setLayers(self.parentImage)
Exemple #3
0
 def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: QWidget = None):
     painter.setRenderHint(QPainter.SmoothPixmapTransform)
     for layer_view in self.layer_views:
         if layer_view.visible and layer_view.image_view is not None:
             painter.setOpacity(layer_view.opacity)
             image_view_origin = layer_view.image_view.spatial.origin
             painter.drawImage(QPointF(image_view_origin[1], image_view_origin[0]), layer_view.displayed_image)
Exemple #4
0
def paint_with_opacity(pixmap: QPixmap, opacity: float):
    transparent_image = QImage(QSize(36, 36),
                               QImage.Format_ARGB32_Premultiplied)
    transparent_image.fill(Qt.transparent)
    painter = QPainter(transparent_image)
    painter.setOpacity(opacity)
    painter.drawPixmap(18 - pixmap.width() / 2, 18 - pixmap.height() / 2,
                       pixmap)
    painter.end()
    return QPixmap.fromImage(transparent_image)
Exemple #5
0
 def getCurrentMaskedImage(self):
     """
     Reduces the layer stack up to self (included),
     taking into account the masks. if self.isClipping is True
     self.mask applies to all lower layers and to self only otherwise.
     The method uses the non color managed rPixmaps to build the masked image.
     For convenience, mainly to be able to use its color space buffers,
     the built image is of type QLayer. It is drawn on a container image,
     created only once.
     @return: masked image
     @rtype: QLayer
     """
     # init containers if needed
     if self.parentImage.useHald:
         return self.getHald()
     if self.maskedThumbContainer is None:
         self.maskedThumbContainer = QLayer.fromImage(
             self.getThumb(), parentImage=self.parentImage)
     if self.maskedImageContainer is None:
         self.maskedImageContainer = QLayer.fromImage(
             self, parentImage=self.parentImage)
     if self.parentImage.useThumb:
         img = self.maskedThumbContainer
     else:
         img = self.maskedImageContainer
     # no thumbnails for containers
     img.getThumb = lambda: img
     # draw lower stack
     qp = QPainter(img)
     top = self.parentImage.getStackIndex(self)
     bottom = 0
     for i, layer in enumerate(self.parentImage.layersStack[bottom:top +
                                                            1]):
         if layer.visible:
             if i == 0:
                 qp.setCompositionMode(QPainter.CompositionMode_Source)
             else:
                 qp.setOpacity(layer.opacity)
                 qp.setCompositionMode(layer.compositionMode)
             if layer.rPixmap is not None:
                 qp.drawPixmap(QRect(0, 0, img.width(), img.height()),
                               layer.rPixmap)
             else:
                 qp.drawImage(QRect(0, 0, img.width(), img.height()),
                              layer.getCurrentImage())
             # clipping
             if layer.isClipping and layer.maskIsEnabled:  #TODO modified 23/06/18
                 # draw mask as opacity mask
                 # mode DestinationIn (set dest opacity to source opacity)
                 qp.setCompositionMode(
                     QPainter.CompositionMode_DestinationIn)
                 omask = vImage.color2OpacityMask(layer.mask)
                 qp.drawImage(QRect(0, 0, img.width(), img.height()), omask)
     qp.end()
     return img
Exemple #6
0
 def getCurrentMaskedImage(self):
     """
     Blend the layer stack up to self (included),
     taking into account the masks. The method uses the
     non color managed rPixmap to build the masked image.
     For convenience, mainly to be able to use its color space buffers,
     the built image is of type bImage. It is drawn on a container image,
     instantiated only once.
     @return: masked image
     @rtype: bImage
     """
     # init containers if needed. They are instantiated only
     # once and updated by drawing.
     if self.parentImage.useHald:
         return self.getHald()
     if self.maskedThumbContainer is None:
         self.maskedThumbContainer = bImage.fromImage(
             self.getThumb(), parentImage=self.parentImage)
     if self.maskedImageContainer is None:
         self.maskedImageContainer = bImage.fromImage(
             self, parentImage=self.parentImage)
     if self.parentImage.useThumb:
         img = self.maskedThumbContainer
     else:
         img = self.maskedImageContainer
     # draw lower stack
     qp = QPainter(img)
     top = self.parentImage.getStackIndex(self)
     bottom = 0
     for i, layer in enumerate(self.parentImage.layersStack[bottom:top +
                                                            1]):
         if layer.visible:
             if i == 0:
                 qp.setCompositionMode(QPainter.CompositionMode_Source)
             else:
                 qp.setOpacity(layer.opacity)
                 qp.setCompositionMode(layer.compositionMode)
             if layer.rPixmap is None:
                 layer.rPixmap = QPixmap.fromImage(layer.getCurrentImage(
                 ))  # TODO modified 9/12/18 validate
             qp.drawPixmap(QRect(0, 0, img.width(), img.height()),
                           layer.rPixmap)
             # clipping
             if layer.isClipping and layer.maskIsEnabled:
                 # draw mask as opacity mask
                 # mode DestinationIn (set dest opacity to source opacity)
                 qp.setCompositionMode(
                     QPainter.CompositionMode_DestinationIn)
                 omask = vImage.color2OpacityMask(layer.mask)
                 qp.drawImage(QRect(0, 0, img.width(), img.height()), omask)
     qp.end()
     return img
Exemple #7
0
 def brushStrokePoly(pixmap, poly, brush):
     """
     Draws the brush stroke defined by a QPolygon
     @param layer:
     @type layer:
     @param x:
     @type x:
     @param y:
     @type y:
     @param r:
     @type r:
     """
     # draw the stroke
     if brush['name'] == 'eraser':
         return
     # drawing into stroke intermediate layer
     pxmp_temp = pixmap.copy()
     qp = QPainter()
     qp.begin(pxmp_temp)
     qp.setCompositionMode(qp.CompositionMode_SourceOver)
     # draw lines
     x_last, y_last = poly.first().x(), poly.first().y()
     for i in range(poly.length() - 1):
         x0, y0 = poly.at(i).x(), poly.at(i).y()
         x, y = poly.at(i + 1).x(), poly.at(i + 1).y()
         x_last, y_last = brushFamily.brushStrokeSeg(
             qp, x_last, y_last, x, y, brush)
     qp.end()
     # draw texture aligned with image
     strokeTex = pxmp_temp
     p = brush['pattern']
     if p is not None:
         if p.pxmp is not None:
             strokeTex = pxmp_temp.copy()
             qp1 = QPainter(strokeTex)
             qp1.setCompositionMode(qp.CompositionMode_DestinationIn)
             qp1.setBrush(QBrush(p.pxmp))
             qp1.fillRect(
                 QRect(0, 0, strokeTex.width(), strokeTex.height()),
                 QBrush(p.pxmp))
             qp1.end()
     # restore source image and paint
     # the whole stroke with current brush opacity
     qp.begin(pixmap)
     # qp.setCompositionMode(qp.CompositionMode_Source)
     # qp.drawImage(QPointF(), layer.strokeDest)
     qp.setOpacity(brush['opacity'])
     qp.setCompositionMode(qp.CompositionMode_SourceOver)
     qp.drawPixmap(QPointF(), strokeTex)  # pxmp_temp)
     qp.end()
Exemple #8
0
 def paintEvent(self, e):
     painter = QPainter(self)
     painter.setOpacity(0.5)
     canvas = None
     for scribble in self.scribbles:
         if scribble.rect:
             if scribble.blend_with_next:
                 if canvas is None:
                     canvas = Overlay()
                 canvas.add(scribble)
             else:
                 if canvas:
                     canvas.add(scribble)
                     canvas.paint(painter)
                     canvas = None
                 else:
                     scribble.paint(painter)
     if canvas:
         canvas.paint(painter)
     painter.setOpacity(1)
     if self.current_wet:
         self.current_wet.paint(painter)
     painter.end()
Exemple #9
0
    def paintEvent(self, event):  # pylint: disable=invalid-name, unused-argument
        p = QPainter(self)
        p.setRenderHint(QPainter.Antialiasing, True)
        p.setPen(Qt.NoPen)
        track_opacity = self._track_opacity
        thumb_opacity = 1.0
        text_opacity = 1.0
        if self.isEnabled():
            track_brush = self._track_color[self.isChecked()]
            thumb_brush = self._thumb_color[self.isChecked()]
            text_color = self._text_color[self.isChecked()]
        else:
            track_opacity *= 0.8
            track_brush = self.palette().shadow()
            thumb_brush = self.palette().mid()
            text_color = self.palette().shadow().color()

        p.setBrush(track_brush)
        p.setOpacity(track_opacity)
        p.drawRoundedRect(
            self._margin,
            self._margin,
            self.width() - 2 * self._margin,
            self.height() - 2 * self._margin,
            self._track_radius,
            self._track_radius,
        )
        p.setBrush(thumb_brush)
        p.setOpacity(thumb_opacity)
        p.drawEllipse(
            self.offset - self._thumb_radius,
            self._base_offset - self._thumb_radius,
            2 * self._thumb_radius,
            2 * self._thumb_radius,
        )
        p.setPen(text_color)
        p.setOpacity(text_opacity)
        font = p.font()
        font.setPixelSize(1.5 * self._thumb_radius)
        p.setFont(font)
        p.drawText(
            QRectF(
                self.offset - self._thumb_radius,
                self._base_offset - self._thumb_radius,
                2 * self._thumb_radius,
                2 * self._thumb_radius,
            ),
            Qt.AlignCenter,
            self._thumb_text[self.isChecked()],
        )
Exemple #10
0
    def paintEvent(self, event):
        super(RetroDrawWidget, self).paintEvent(event)

        painter = QPainter(self)

        rectTarget = self.rect()
        rectSource = QRect(QPoint(0, 0), self.canvasSize)
        painter.drawPixmap(rectTarget, self.drawable.qpixmap, rectSource)

        if self._guide and self._guideEnabled:
            painter.setOpacity(self._guideOpacity)
            self._paintZoomedGuide(painter)
        if self._gridEnabled:
            painter.setOpacity(self._gridOpacity)
            painter.drawImage(rectTarget, self.grid, rectTarget)

        painter.setOpacity(1.0)
        painter.drawImage(rectTarget, self._scratch, rectTarget)

        painter.end()
Exemple #11
0
 def paintEvent(self, event):
     painter = QPainter()
     painter.begin(self)
     painter.setOpacity(self.pixmap_opacity)
     painter.drawPixmap(0, 0, self.old_pixmap)
     painter.end()
Exemple #12
0
class IconButton(QWidget):
    clicked = Signal(bool)

    def __init__(self, image_path, size=40, checkbox=False):
        super(IconButton, self).__init__()
        self.setMinimumSize(size, size)
        self.setMaximumSize(size, size)

        self.hover = False
        self.checkbox = checkbox
        self.checked = False

        pixmap_image = ""
        if os.path.exists(image_path):
            pixmap_image = image_path

        pixmap = QPixmap(pixmap_image)
        self.pixmap = pixmap.scaled(QSize(size, size), Qt.KeepAspectRatio,
                                    Qt.SmoothTransformation)

        self.checked_brush = QBrush(QColor("red"))
        self.painter = QPainter()

    def enterEvent(self, event):
        QApplication.setOverrideCursor(Qt.PointingHandCursor)
        self.hover = True
        self.repaint()
        super(IconButton, self).enterEvent(event)

    def leaveEvent(self, event):
        QApplication.restoreOverrideCursor()
        self.hover = False
        self.repaint()
        super(IconButton, self).leaveEvent(event)

    def mousePressEvent(self, event):
        if self.checkbox:
            self.checked = not self.checked

        self.clicked.emit(self.checked)
        self.repaint()
        super(IconButton, self).mousePressEvent(event)

    def paintEvent(self, event):
        self.painter.begin(self)
        self.draw()
        self.painter.end()

    def draw(self):
        rect = self.rect()

        self.painter.setOpacity(0.5)

        if self.hover:
            self.painter.setOpacity(1)

        if self.checkbox and self.checked:
            self.painter.setOpacity(1)
            self.painter.setBrush(self.checked_brush)
            self.painter.setPen(Qt.NoPen)
            self.painter.drawRect(rect)

        self.painter.drawPixmap(rect, self.pixmap)
    def draw(self, painter: QPainter, block_length: int):
        self.pixel_length = block_length / Block.WIDTH

        self.scroll_brush = QBrush(Qt.blue)
        self.scroll_pen = QPen(self.scroll_brush, 2 * self.pixel_length)

        self.acceleration_brush = QBrush(Qt.red)
        self.acceleration_pen = QPen(self.acceleration_brush,
                                     2 * self.pixel_length)

        painter.setPen(self.scroll_pen)
        painter.setBrush(self.scroll_brush)

        auto_scroll_type_index = self.auto_scroll_row >> 4
        auto_scroll_routine_index = self.auto_scroll_row & 0b0001_1111

        if auto_scroll_type_index in [
                SPIKE_CEILING_SCROLL,
                UP_TIL_DOOR_SCROLL,
                WATER_LEVEL_SCROLL,
                UP_RIGHT_DIAG_SCROLL,
        ]:
            # not visualized
            return
        elif auto_scroll_type_index not in [
                HORIZONTAL_SCROLL_0, HORIZONTAL_SCROLL_1
        ]:
            # illegal value, those appear in the vanilla ROM, though; so error out
            return

        first_movement_command_index = (self.rom.int(
            AScroll_HorizontalInitMove + auto_scroll_routine_index) + 1) % 256
        last_movement_command_index = (self.rom.int(
            AScroll_HorizontalInitMove + auto_scroll_routine_index + 1)) % 256

        self.horizontal_speed = 0
        self.vertical_speed = 0

        self.current_pos = self._determine_auto_scroll_start(block_length)

        for movement_command_index in range(first_movement_command_index,
                                            last_movement_command_index + 1):

            movement_command = self.rom.int(AScroll_Movement +
                                            movement_command_index)
            movement_repeat = self.rom.int(AScroll_MovementRepeat +
                                           movement_command_index)

            self._execute_movement_command(painter, movement_command,
                                           movement_repeat)

        stop_marker = QRectF(QPoint(0, 0), QSizeF(10, 10) * self.pixel_length)
        stop_marker.moveCenter(self.current_pos)

        painter.setPen(Qt.NoPen)
        painter.drawRect(stop_marker)

        painter.setPen(self.scroll_pen)
        painter.setBrush(self.scroll_brush)

        painter.setOpacity(0.2)
        painter.drawPolygon(self.screen_polygon)
Exemple #14
0
    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)
Exemple #15
0
 def paintEvent(self, event):
     p = QPainter(self)
     p.setOpacity(0)