コード例 #1
0
ファイル: label_dialog.py プロジェクト: sbrunner/edocuments
 def set_image(self, image_filename):
     size = 800
     pixmap = QPixmap(image_filename)
     if pixmap.width() > pixmap.height():
         if pixmap.width() > size:
             pixmap = pixmap.scaledToWidth(size)
     else:
         if pixmap.height() > size:
             pixmap = pixmap.scaledToHeight(size)
     self.ui.label.setPixmap(pixmap)
     self.ui.label.setMask(pixmap.mask())
     self.ui.label.show()
コード例 #2
0
    def draw_indicator(indicator: int):
        pixmap = QPixmap(24, 24)

        painter = QPainter(pixmap)
        w, h = pixmap.width(), pixmap.height()

        painter.fillRect(0, 0, w, h, QBrush((QColor(0, 0, 200, 255))))

        pen = QPen(QColor("white"))
        pen.setWidth(2)
        painter.setPen(pen)

        font = util.get_monospace_font()
        font.setBold(True)
        font.setPixelSize(16)
        painter.setFont(font)

        f = QFontMetrics(painter.font())
        indicator_str = str(indicator) if indicator < 10 else "+"

        fw = f.width(indicator_str)
        fh = f.height()
        painter.drawText(math.ceil(w / 2 - fw / 2), math.ceil(h / 2 + fh / 4), indicator_str)

        painter.end()
        return QIcon(pixmap)
コード例 #3
0
ファイル: fontgenerator.py プロジェクト: SolitonNew/tcpy
    def buildCharPreview(self):        
        char = self.selectedChar - self.charFrom.value()
        if char < 0:
            char = 0
        if char >= len(self.charSizes):
            char = len(self.charSizes) - 1
        
        k = 5
        s_x = self.charSizes[char][0]
        w = self.charSizes[char][1]
        
        charPix = self.chars.pixmap()
        charImage = charPix.toImage()

        self.charPreview.resize(w * k + 1, charPix.height() * k + 1)

        pix = QPixmap(w * k, charPix.height() * k)
        p = QPainter()
        p.begin(pix)
        p.setBrush(QBrush(QColor(0xffffff), Qt.SolidPattern))
        p.drawRect(0, 0, pix.width() - 1, pix.height() - 1)

        p.setBrush(QBrush(QColor(0x0), Qt.SolidPattern))        
        for x in range(w):
            for y in range(charPix.height()):
                if QColor(charImage.pixel(s_x + x, y)).lightness() == 0x0:
                    p.drawRect(x * k, y * k, k, k)
        p.end()
        self.charPreview.setPixmap(pix)
コード例 #4
0
ファイル: themes.py プロジェクト: georgehank/manuskript
def createThemePreview(theme, screenRect, size=QSize(200, 120)):
    if type(theme) == str and os.path.exists(theme):
        # Theme is the path to an ini file
        themeDatas = loadThemeDatas(theme)
    else:
        themeDatas = theme

    pixmap = generateTheme(themeDatas, screenRect)

    addThemePreviewText(pixmap, themeDatas, screenRect)

    px = QPixmap(pixmap).scaled(size, Qt.KeepAspectRatio)

    w = px.width() / 10
    h = px.height() / 10
    r = themeTextRect(themeDatas, screenRect)

    painter = QPainter(px)
    painter.drawPixmap(QRect(w, h, w * 4, h * 5), pixmap,
                       QRect(r.topLeft() - QPoint(w / 3, h / 3), QSize(w * 4, h * 5)))
    painter.setPen(Qt.white)
    painter.drawRect(QRect(w, h, w * 4, h * 5))
    painter.end()

    return px
コード例 #5
0
ファイル: detection.py プロジェクト: smajida/detection
    def drawRects(self, source, rectsTree, scale):
        """Draw rectangles in 'rectsTree' on 'source'.
        """
        pixmap = QPixmap(source)
        self.drawBackground(pixmap)

        def drawRect(node, parentHash):
            painter = QtGui.QPainter(pixmap)
            roi, param, tracking = node.data
            x, y, w, h = common.scaleRect(roi, scale)
            painter.setPen(param.color)
            funcTable = {
                self.FILL_MASK: self.fillMask,
                self.FILL_BLUR: self.fillBlur,
                self.FILL_IMAGE: self.fillImage,
                self.FILL_COLOR: self.fillColor,
                self.FILL_OUTLINE: self.fillOutline
                         }
            for fill, func in funcTable.iteritems():
                if param.fill == fill:
                    func(pixmap, painter, (x, y, w, h), param, source)
            if param.tracking:
                self.drawTracking(painter, tracking, scale)
            if param.showName:
                painter.drawText(x, y, param.name)
            return param.hash

        h, w = pixmap.height(), pixmap.width()
        rectsTree.map(None, drawRect)
        painter = QtGui.QPainter(source)
        painter.drawPixmap(0, 0, pixmap)
コード例 #6
0
ファイル: hsvWidget.py プロジェクト: lr-morales/JdeRobot
	def paintEvent(self,event=None):
	    
	    painter = QPainter(self)
	    pixmap=QPixmap(":/images/wheelfinal.png")

	    #painter.begin(self)
	    #painter.drawPixmap(QtCore.QRect(self.left, self.top, self.width, self.height), self.pixmap)
	    painter.drawPixmap(self.rect(), pixmap)
	    self.resize(pixmap.width(),pixmap.height())
	    
	    pen = QPen(Qt.red, 3)
	    painter.setPen(pen)
	    
	    painter.drawArc (self.disc_center-int(self.distance_from_center(self.points[0])) , 
	                        self.disc_center - int(self.distance_from_center (self.points[0])) , 
	                        2*int(self.distance_from_center(self.points[0])) , 
	                        2*int(self.distance_from_center(self.points[0])) , 
	                        int(16*self.hue_min) , 
	                        int(16*(self.hue_max-self.hue_min)))#arc joining point 0 and point 1
	    painter.drawLine(int(self.points[0][0]),int(self.points[0][1]),int(self.points[3][0]),int(self.points[3][1]))#line joining point 0 and point 3
	    painter.drawArc(self.disc_center-int(self.distance_from_center(self.points[2])) , 
	                        self.disc_center - int(self.distance_from_center (self.points[2])) , 
	                        2*int(self.distance_from_center(self.points[2])) , 
	                        2*int(self.distance_from_center(self.points[2])) , 
	                        int(16*self.hue_min) , 
	                        int(16*(self.hue_max-self.hue_min)))#arc joining point 2 and 3
	    painter.drawLine(int(self.points[1][0]),int(self.points[1][1]),int(self.points[2][0]),int(self.points[2][1]))#line joining point 1 and 2
	    
	    self.update()
コード例 #7
0
ファイル: aboutDialog.py プロジェクト: ilastik/ilastik
    def _setup_layout(self):
        main_layout = QVBoxLayout()
        content_layout = QHBoxLayout()
        splash_path = os.path.join(
            os.path.split(ilastik.__file__)[0], 'ilastik-splash.png'
        )
        splash_pixmap = QPixmap(splash_path)
        logo_label = QLabel()
        logo_label.setPixmap(splash_pixmap)
        content_layout.addWidget(logo_label)

        text_label = QLabel()
        text_label.setWordWrap(True)
        text_label.setTextFormat(Qt.RichText)
        text_label.setOpenExternalLinks(True)
        text_label.setText(about_text)
        content_layout.addWidget(text_label)

        btn_box = QDialogButtonBox(QDialogButtonBox.Ok)
        btn_box.accepted.connect(self.accept)

        main_layout.addLayout(content_layout)
        main_layout.addWidget(btn_box)

        self.setLayout(main_layout)
        self.setStyleSheet("background-color: white;")
        self.setWindowTitle('About ilastik')
        self.setFixedSize(splash_pixmap.width() * 2.5, splash_pixmap.height() * 1.05)
コード例 #8
0
ファイル: 15_image_test.py プロジェクト: nnaabbcc/exercise
    def __init_ui(self):
        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)

        label = QLabel(self)
        image = QPixmap('15_flower.jpg')
        label.setPixmap(image)
        label.move(0, 0)
        self.resize(image.width(), image.height())
コード例 #9
0
ファイル: gui_old.py プロジェクト: hristy93/FallingRocks
class PlayerUI(ShapeUI):
    def __init__(self, parent, game):
        super().__init__(parent, game)
        self.player = game.player
        self.speed = game.player_speed

        self.pixmap = QPixmap("images/smile3.png")
        self.image_height_fix = 48  # 48

        self.width = self.pixmap.width()
        self.height = self.pixmap.height()

        self.set_shape_size()

        self.set_initial_position()
        self.show()

    def set_initial_position(self):
        """Set the initial position of the player and moves the player
        there.
        """
        self.x = (self.field_width - self.image_size[0]) / 2
        self.y = self.field_height - 50
        self.move(self.x, self.y)

    @property
    def is_player_invincible(self):
        """Checks if the player is invincible"""
        return self.player.is_player_invincible

    def set_player_invinciblity(self):
        """Sets the player's invincibility to the opposite of the current
        value.
        """
        self.player.set_player_invinciblity()

    @pyqtSlot()
    def move_left(self):
        """Moves the player to the left and checks if the move is valid
        (if the move is out of the game field).
        """
        print("left")
        if(self.x - self.speed > 0):
            self.x -= self.speed
            self.move(self.x, self.y)

    @pyqtSlot()
    def move_right(self):
        """Moves the player to the right and checks if the move is valid
        (if the move is out of the game field).
        """
        print("right")
        if(self.x + self.speed < self.field_width -
           self.image_size[0]):
            self.x += self.speed
            self.move(self.x, self.y)
コード例 #10
0
ファイル: qt08_paint04.py プロジェクト: kiorry/PYQT
class ShapeWidget(QWidget):  
	def __init__(self,parent=None):  
		super(ShapeWidget,self).__init__(parent)
		self.i = 1
		self.mypix()
		self.timer = QTimer()
		self.timer.setInterval(500)  # 500毫秒
		self.timer.timeout.connect(self.timeChange)   
		self.timer.start()

    # 显示不规则 pic
	def mypix(self):
		self.update()
		if self.i == 5:
			self.i = 1
		self.mypic = {1: './images/left.png', 2: "./images/up.png", 3: './images/right.png', 4: './images/down.png'}
		self.pix = QPixmap(self.mypic[self.i], "0", Qt.AvoidDither | Qt.ThresholdDither | Qt.ThresholdAlphaDither)   
		self.resize(self.pix.size())
		self.setMask(self.pix.mask())  
		self.dragPosition = None

	def mousePressEvent(self, event):
		if event.button() == Qt.LeftButton:
			self.m_drag=True
			self.m_DragPosition=event.globalPos()-self.pos()
			event.accept()
			self.setCursor(QCursor(Qt.OpenHandCursor))

	def mouseMoveEvent(self, QMouseEvent):
		if Qt.LeftButton and self.m_drag:
			self.move(QMouseEvent.globalPos()- self.m_DragPosition )
			QMouseEvent.accept()
	
	def mouseReleaseEvent(self, QMouseEvent):
		self.m_drag=False
		self.setCursor(QCursor(Qt.ArrowCursor))
        
	def paintEvent(self, event):
		painter = QPainter(self)
		painter.drawPixmap(0, 0, self.pix.width(),self.pix.height(),self.pix)
    
	# 鼠标双击事件
	def mouseDoubleClickEvent(self, event):
		if event.button() == 1:
			self.i += 1
			self.mypix()

    # 每500毫秒修改paint
	def timeChange(self):
		self.i += 1
		self.mypix()
コード例 #11
0
ファイル: padnavigator.py プロジェクト: Axel-Erfurt/pyqt5
class RoundRectItem(QGraphicsObject):
    def __init__(self, bounds, color, parent=None):
        super(RoundRectItem, self).__init__(parent)

        self.fillRect = False
        self.bounds = QRectF(bounds)
        self.pix = QPixmap()

        self.gradient = QLinearGradient()
        self.gradient.setStart(self.bounds.topLeft())
        self.gradient.setFinalStop(self.bounds.bottomRight())
        self.gradient.setColorAt(0, color)
        self.gradient.setColorAt(1, color.darker(200))

        self.setCacheMode(QGraphicsItem.ItemCoordinateCache)

    def setFill(self, fill):
        self.fillRect = fill
        self.update()

    def fill(self):
        return self.fillRect

    fill = pyqtProperty(bool, fill, setFill)

    def paint(self, painter, option, widget):
        painter.setPen(Qt.NoPen)
        painter.setBrush(QColor(0, 0, 0, 64))
        painter.drawRoundedRect(self.bounds.translated(2, 2), 25.0, 25.0)

        if self.fillRect:
            painter.setBrush(QApplication.palette().brush(QPalette.Window))
        else:
            painter.setBrush(self.gradient)

        painter.setPen(QPen(Qt.black, 1))
        painter.drawRoundedRect(self.bounds, 25.0, 25.0)
        if not self.pix.isNull():
            painter.scale(1.95, 1.95)
            painter.drawPixmap(-self.pix.width() / 2, -self.pix.height() / 2, self.pix)

    def boundingRect(self):
        return self.bounds.adjusted(0, 0, 2, 2)

    def pixmap(self):
        return QPixmap(self.pix)

    def setPixmap(self, pixmap):
        self.pix = QPixmap(pixmap)
        self.update()
コード例 #12
0
    def loadImage(self, path):
        self.markable_picture = QMarkablePicture(self)
        hbox = QHBoxLayout(self)
        picture = QPixmap(path)

        if picture.width() > self.maximumWidth():
            picture = picture.scaledToWidth(self.maximumWidth())
        if picture.height() > self.maximumHeight():
            picture = picture.scaledToHeight(self.maximumHeight())

        self.markable_picture.setPixmap(picture)
        hbox.addWidget(self.markable_picture)
        hbox.setContentsMargins(0, 0, 0, 0)
        self.setLayout(hbox)
コード例 #13
0
ファイル: cml.py プロジェクト: lmann03/roadside-viewer
    def initUI(self):
        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)

        button = QPushButton('PyQt5 button', self)
        button.setToolTip('This is an example button')
        button.move(0,0)
        button.clicked.connect(self.on_click)

        # # Create widget
        label = QLabel(self)
        pixmap = QPixmap(os.path.join(full_mask_path, 'EN20160520L039-26_mask.jpg'))
        label.setPixmap(pixmap)
        self.resize(pixmap.width(),pixmap.height())
        self.show()
コード例 #14
0
 def set_cursor_shape(self, shape):
     '''
     Set the shape of cursor, the param shape should be one of the keys
     of the global variable cursor_shape_dict.
     '''
     if cursor_shape_dict.get(shape):
         pix = QPixmap(cursor_shape_dict[shape])
         if shape == "shape_start_cursor":
             cur = QCursor(pix, hotX=8, hotY=8)
         elif shape.startswith(CURSOR_SHAPE_COLOR_PEN_PREFIX):
             cur = QCursor(pix, hotX=0, hotY=pix.height())
         else:
             cur = QCursor(pix, hotX=5, hotY=5)
     else:
         cur = QCursor(Qt.ArrowCursor)
     self.setCursor(cur)
コード例 #15
0
ファイル: FrameSelecter.py プロジェクト: 3qwasd/jobs
class ImageToggleButton(ToggleButton):

	def __init__(self,imgId,img):
		super(ImageToggleButton, self).__init__()
		self.id = imgId
		self.pixMap = QPixmap(img)
		eliminateBackgroundColor(self.pixMap)
		self.backBrush = QBrush(QColor(img.pixel(0,0)))

	def paintEvent(self,event):
		super().paintEvent(event)
		painter = QPainter(self)
		painter.fillRect(4,4,frameWidth,frameHeight,self.backBrush)
		painter.drawPixmap(4+(frameWidth-self.pixMap.width())//2,4+(frameHeight-self.pixMap.height())//2,self.pixMap)
		if self.isChecked():
			painter.setPen(self.checkedPen)
			painter.drawRect(3,3,self.width()-6,self.height()-6)
コード例 #16
0
ファイル: themes.py プロジェクト: olivierkes/manuskript
def createThemePreview(theme, screenRect, size=QSize(200, 120)):
    """
    Generates a QPixmap preview for given theme.

    Theme can be either a string containing the filename of the ini
    file with the theme settings, or it can be a dict with the settings.

    If theme is a filename, the result is cached.
    """

    # Checking whether theme is a string or dict
    if type(theme) == str and os.path.exists(theme):
        # Theme is the path to an ini file
        themeDatas = loadThemeDatas(theme)
        fromFile = True
    else:
        themeDatas = theme
        fromFile = False

    # Check if item is in cache
    if fromFile and theme in _thumbCache:
        if _thumbCache[theme][0] == themeDatas:
            return _thumbCache[theme][1]

    pixmap = generateTheme(themeDatas, screenRect)

    addThemePreviewText(pixmap, themeDatas, screenRect)

    px = QPixmap(pixmap).scaled(size, Qt.KeepAspectRatio)

    w = px.width() / 10
    h = px.height() / 10
    r = themeTextRect(themeDatas, screenRect)

    painter = QPainter(px)
    painter.drawPixmap(QRect(w, h, w * 4, h * 5), pixmap,
                       QRect(r.topLeft() - QPoint(w / 3, h / 3), QSize(w * 4, h * 5)))
    painter.setPen(Qt.white)
    painter.drawRect(QRect(w, h, w * 4, h * 5))
    painter.end()

    # If theme is a themefile, we keep it in cache
    if fromFile:
        _thumbCache[theme] = [themeDatas, px]

    return px
コード例 #17
0
class QImageArea(QWidget):
    def __init__(self, parent=None):
        QWidget.__init__(self, parent)

    def loadImage(self, path):
        self.picture_label = QLabel(self)
        hbox = QHBoxLayout(self)
        self.picture = QPixmap(path)

        self.picture_label.setPixmap(self.picture)
        hbox.addWidget(self.picture_label)
        hbox.setContentsMargins(0, 0, 0, 0)
        self.setLayout(hbox)

    def getImageWidth(self):
        return self.picture.width()

    def getImageHeight(self):
        return self.picture.height()
コード例 #18
0
ファイル: colorbutton.py プロジェクト: theall/Python-Tiled
 def setColor(self, color):
     if type(color)!=QColor:
         color = QColor(color)
     if (self.mColor == color or not color.isValid()):
         return
     self.mColor = color
     size = QSize(self.iconSize())
     size.setWidth(size.width()-2)
     size.setHeight(size.height()-2)
     pixmap = QPixmap(size)
     pixmap.fill(self.mColor)
     painter = QPainter(pixmap)
     border = QColor(Qt.black)
     border.setAlpha(128)
     painter.setPen(border)
     painter.drawRect(0, 0, pixmap.width() - 1, pixmap.height() - 1)
     painter.end()
     self.setIcon(QIcon(pixmap))
     self.colorChanged.emit(color)
コード例 #19
0
  def setSampleImage(self, pathToFile):

    self.graphicsView.hide()

    #clear scene
    self.graphicsScene.clear()

    #load file
    tmpImage = QImage(pathToFile)
    self.originalHeight = tmpImage.height()
    self.originalWidth = tmpImage.width()
    tmpPixmap = QPixmap(1)
    tmpPixmap.convertFromImage(tmpImage.scaledToWidth(300))
    self.scaledHeight = tmpPixmap.height()
    self.scaledWidth = tmpPixmap.width()

    #add to scene and show
    self.graphicsScene.addPixmap(tmpPixmap)
    self.graphicsView.show()
コード例 #20
0
 def put_cv2_image(self, image, widget):
     height, width = image.shape[0:2]
     qImg = self.cv2toQImage(image)
     pixmap = QPixmap(qImg)
     if height > width:
         if height > self.preview_size:
             pixmap = pixmap.scaledToHeight(self.preview_size)
     else:
         if width > self.preview_size:
             pixmap = pixmap.scaledToWidth(self.preview_size)
     widget.setPixmap(pixmap)
     #give hints to DrawableLabel() and MyLabel()
     widget.perspective = self.perspective
     widget.focus = self.focus
     widget.slitpos = self.slitpos
     w = pixmap.width()
     h = pixmap.height()
     x = ( self.preview_size - w ) // 2
     y = ( self.preview_size - h ) // 2
     widget.geometry = x,y,w,h
コード例 #21
0
ファイル: puzzle.py プロジェクト: death-finger/Scripts
    def startDrag(self, supportedActions):
        item = self.currentItem()

        itemData = QByteArray()
        dataStream = QDataStream(itemData, QIODevice.WriteOnly)
        pixmap = QPixmap(item.data(Qt.UserRole))
        location = item.data(Qt.UserRole+1)

        dataStream << pixmap << location

        mimeData = QMimeData()
        mimeData.setData('image/x-puzzle-piece', itemData)

        drag = QDrag(self)
        drag.setMimeData(mimeData)
        drag.setHotSpot(QPoint(pixmap.width()/2, pixmap.height()/2))
        drag.setPixmap(pixmap)

        if drag.exec_(Qt.MoveAction) == Qt.MoveAction:
            if self.currentItem() is not None:
                self.takeItem(self.row(item))
コード例 #22
0
ファイル: crop.py プロジェクト: dexpota/type-do-get
    def __init__(self, imagepath, binpath):
        super().__init__()

        QToolTip.setFont(QFont('SansSerif', 10))
        self.setToolTip('This is a <b>QWidget</b> widget')

        self.imageLabel = QLabel(self)
        self.imageLabel.setBackgroundRole(QPalette.Base)
        self.imageLabel.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
        self.imageLabel.setScaledContents(True)

        self.overlay = Overlay(self.imageLabel, binpath)
        self.setCentralWidget(self.overlay)

        self.overlay.c.cropImage.connect(self.crop)
        #self.overlay.setSizePolicy(QSizePolicy.Maximum,QSizePolicy.Maximum)

        self.imagepath = imagepath
        image = QPixmap(imagepath)
        w = image.width()
        h = image.height()

        rec = QApplication.desktop().screenGeometry();
        dsk_h = rec.height();
        dsk_w = rec.width();

        wdw_w = min(0.7 * dsk_w, w) # Window's width 85% of screen's size
        self.ratio = wdw_w / w      # Storing the ratio for later use
        wdw_h = h * self.ratio      # A simple proportion to get the height, because we want to mantain the aspect ratio

        image = image.scaled(wdw_w, wdw_h, transformMode=QtCore.Qt.SmoothTransformation)

        self.imageLabel.setPixmap(image)
        self.imageLabel.adjustSize()

        self.setGeometry(dsk_w/2 - wdw_w/2, dsk_h/2 - wdw_h/2, wdw_w, wdw_h)
        self.setWindowTitle('Tooltips')
        self.show()
コード例 #23
0
ファイル: Table_PyQt.py プロジェクト: cuiyixin555/Deblur-GUI
def main():
    app = QApplication(sys.argv)

    filename = os.path.join(os.path.dirname(__file__), "assets.db")
    create = not QFile.exists(filename)
    db = QSqlDatabase.addDatabase("QSQLITE")
    db.setDatabaseName(filename)
    if not db.open():
        QMessageBox.warning(None, "Asset Manager",
            ("Database Error: {0}"
            .format(db.lastError().text())))
        sys.exit(1)

    splash = None
    if create:
        app.setOverrideCursor(QCursor(Qt.WaitCursor))
        splash = QLabel()
        pixmap = QPixmap(":/assetmanagersplash.png")
        splash.setPixmap(pixmap)
        splash.setMask(pixmap.createHeuristicMask())
        splash.setWindowFlags(Qt.SplashScreen)
        rect = app.desktop().availableGeometry()
        splash.move((rect.width() - pixmap.width()) / 2,
                    (rect.height() - pixmap.height()) / 2)
        splash.show()
        app.processEvents()
        createFakeData()

    form = MainForm()
    form.show()
    if create:
        splash.close()
        app.processEvents()
        app.restoreOverrideCursor()
    app.exec_()
    del form
    del db
コード例 #24
0
class PaintWidget(QWidget):
    def __init__(self, parent, model, pixel_size, vnc=None):
        super().__init__(parent)
        self.fb = FrameBuffer(model)
        self.pixel_size = pixel_size
        self.mPixmap = QPixmap()
        self.vnc = vnc

    def paintEvent(self, event):
        if self.fb.pixels:
            pixmap = QPixmap(self.size() / self.pixel_size)
            pixmap.fill(Qt.white)
            painter = QPainter(pixmap)
            painter.drawPixmap(0, 0, self.mPixmap)
            self._redraw(painter)
            self.mPixmap = pixmap
            self.fb.pixels = {}

        qp = QPainter(self)
        copied_pixmap = self.mPixmap
        if self.pixel_size != 1:
            # Only call scaled if needed.
            copied_pixmap = self.mPixmap.scaled(
                self.mPixmap.width() * self.pixel_size,
                self.mPixmap.height() * self.pixel_size)
        qp.drawPixmap(0, 0, copied_pixmap)

    def _redraw(self, qp):
        for (x, y), color in self.fb.pixels.items():
            qp.setPen(QColor.fromRgb(color))
            qp.drawPoint(x, y)

        if self.vnc:
            self.vnc.redraw(self.fb.pixels)

    def draw_point(self, x, y, color):
        return self.fb.draw_point(x, y, color)
コード例 #25
0
ファイル: splash.py プロジェクト: roderickmackenzie/gpvdm
	def init(self):
		self.window = loadUi(os.path.join(get_ui_path(),"splash.ui"))
		self.window.setWindowFlags(Qt.FramelessWindowHint|Qt.WindowStaysOnTopHint)
		self.center()
		self.window.li.setText(notice()+"\n"+version())
		self.window.setModal(Qt.WindowModal)
		self.window.image.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
		self.window.image.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)

		window_h=self.window.height()
		window_w=self.window.width()
		r=random.randint(2, 3)
		image=QPixmap(os.path.join(get_image_file_path(),"splash"+str(r)+".png"))
		image.scaledToHeight(window_h)

		w=image.width()
		h=image.height()
		x_max=w-window_h-window_w/2

		hour=float(time.strftime("%H"))*60
		m=float(time.strftime("%m"))
		tot=hour+m
		my_max=float(24*60)

		value=tot/my_max

		xpos=int(x_max*value)+window_w/2
		print("xpos=",xpos)
		scene=QGraphicsScene();
		scene.setSceneRect(xpos, 0, 0, h)
		self.window.image.setScene(scene)

		self.window.show()

		scene.addPixmap(image);

		QTimer.singleShot(1500, self.callback_destroy)
コード例 #26
0
ファイル: main.py プロジェクト: lauracavaliere/appsAway
    def createTopGroupBox(self):
        self.topGroupBox = QGroupBox(self.title)

        self.topGroupBox.setAlignment(Qt.AlignHCenter)

        layout = QVBoxLayout()

        self.pushUpdateButton.setDefault(True)

        out = subprocess.Popen(['./appsAway_checkUpdates.sh'],
                               stdout=subprocess.PIPE,
                               stderr=subprocess.STDOUT)

        stdout, stderr = out.communicate()

        if b"true" in stdout:
            self.pushUpdateButton.setEnabled(True)
            self.pushUpdateButton.setText("Update Available")
        elif b"false" in stdout:
            self.pushUpdateButton.setEnabled(False)
            self.pushUpdateButton.setText("Everything is Up to Date!")

        layout.addWidget(self.pushUpdateButton)

        pixmap = QPixmap(self.image)
        if pixmap.height() > 250:
            pixmap = pixmap.scaledToHeight(250, Qt.SmoothTransformation)

        self.label.setPixmap(pixmap)
        #self.resize(pixmap.width(),pixmap.height())
        #self.show()
        layout.addWidget(self.label)
        layout.addStretch(1)
        layout.setAlignment(Qt.AlignCenter)
        self.topGroupBox.setLayout(layout)

        self.pushUpdateButton.clicked.connect(self.startUpdate)
コード例 #27
0
class RedimensionarImagem(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        super().setupUi(self)
        self.btnEscolherArquivo.clicked.connect(self.abrir_imagem)
        self.btnRedimensionar.clicked.connect(self.redimensionar)
        self.btnSalvar.clicked.connect(self.salvar)

    def abrir_imagem(self):
        imagem, _ = QFileDialog.getOpenFileName(
            self.centralwidget,  # QUem é pai da caixa de Diálogo
            'Abrir Imagem',  # título da caixa de Diálogo
            'C:\\Users\\desen\\Pictures\\',  # caminho que ela vai inciar
            # options=QFileDialog.DontUseNativeDialog Se não quisar usar a caixa nativa do sistema
        )
        self.edtAbrirArquivo.setText(imagem)
        self.orignal_img = QPixmap(imagem)
        self.lblImg.setPixmap(self.orignal_img)
        self.edtLargura.setText(str(self.orignal_img.width()))
        self.edtAltura.setText(str(self.orignal_img.height()))

    def redimensionar(self):
        largura = int(self.edtLargura.text())
        self.nova_imagem = self.orignal_img.scaledToWidth(
            largura)  # calcula altomatimente com base na largura passada
        self.lblImg.setPixmap(self.nova_imagem)
        self.edtLargura.setText(str(self.nova_imagem.width()))
        self.edtAltura.setText(str(self.nova_imagem.height()))

    def salvar(self):
        imagem, _ = QFileDialog.getSaveFileName(
            self.centralwidget,  # QUem é pai da caixa de Diálogo
            'Salvar Imagem',  # título da caixa de Diálogo
            'C:\\Users\\desen\\Pictures\\',  # caminho que ela vai inciar
            # options=QFileDialog.DontUseNativeDialog Se não quisar usar a caixa nativa do sistema
        )
        self.nova_imagem.save(imagem, 'PNG')
コード例 #28
0
ファイル: Wasp-Emoji.py プロジェクト: batuhan-ince/bot
    def initUI(self):
        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)
        poop_label = QLabel(self)
        self.show()

        input_str = input(
            "Please Input the Name of the Emoji you want to see:)) \n To Finish Process type 'finish' "
        )
        while not input_str == "finish":
            input_str = input(
                "Please Input the Name of the Emoji you want to see:))")

            if input_str == "poop":
                poop = QPixmap('poop.png')
                poop_label.setPixmap(poop)
                self.resize(poop.width(), poop.height())
                self.update()
            elif input_str == "smiley":
                smiley = QPixmap('smiley.png')
                poop_label.setPixmap(smiley)
                self.resize(smiley.width(), smiley.height())
                self.update()
            elif input_str == "smirk":
                smirk = QPixmap('smirk.png')
                poop_label.setPixmap(smirk)
                self.resize(smirk.width(), smirk.height())
                self.update()

            elif input_str == "surprised":
                surprised = QPixmap('surprised.png')
                poop_label.setPixmap(surprised)
                self.resize(surprised.width(), surprised.height())
                self.update()
            elif input_str == "heart_eyes":
                heart_eyes = QPixmap('heart_eyes.png')
                poop_label.setPixmap(heart_eyes)
                self.resize(heart_eyes.width(), heart_eyes.height())
                self.update()
            elif input_str == "crying":
                crying = QPixmap('crying.png')
                poop_label.setPixmap(crying)
                self.resize(crying.width(), crying.height())
                self.update()
コード例 #29
0
    def update_label_object(self):

        # Showing text while image is loading and processing
        self.label.setText('Processing ...')

        # Opening dialog window to choose an image file
        # Giving name to the dialog window --> 'Choose Image to Open'
        # Specifying starting directory --> '.'
        # Showing only needed files to choose from --> '*.png *.jpg *.bmp'
        image_path = \
            QtWidgets.QFileDialog.getOpenFileName(self, 'Choose Image to Open',
                                                  '.',
                                                  '*.png *.jpg *.bmp')

        # Variable 'image_path' now is a tuple that consists of two elements
        # First one is a full path to the chosen image file
        # Second one is a string with possible extensions

        # Checkpoint
        print(type(image_path))  # <class 'tuple'>
        print(image_path[0])  # /home/my_name/Downloads/example.png
        print(image_path[1])  # *.png *.jpg *.bmp

        # Slicing only needed full path
        image_path = image_path[0]  # /home/my_name/Downloads/example.png

        # Opening image with QPixmap class that is used to
        # show image inside Label object
        pixmap_image = QPixmap(image_path)

        # Passing opened image to the Label object
        self.label.setPixmap(pixmap_image)

        # Getting opened image width and height
        # And resizing Label object according to these values
        self.label.resize(pixmap_image.width(), pixmap_image.height())
コード例 #30
0
class PushButton(QPushButton):
    def __init__(self,parent = None):
        super(PushButton,self).__init__(parent)
        self.status = 0 

    def loadPixmap(self, pic_name):	
        self.pixmap = QPixmap(pic_name)
        self.btn_width = self.pixmap.width()/4
        self.btn_height = self.pixmap.height()
        self.setFixedSize(self.btn_width, self.btn_height)

    def enterEvent(self,event):	
        self.status = 1 
        self.update()

    def mousePressEvent(self,event):	
        self.mouse_press = True
        self.status = 2 
        self.update()		

    def mouseReleaseEvent(self,event):	
        if(self.mouse_press):		
            self.mouse_press = False
            self.status = 3 
            self.update()
            self.clicked.emit(True)		

    def leaveEvent(self,event):	
        self.status = 0 
        self.update()

    def paintEvent(self,event):	
        self.painter = QPainter()
        self.painter.begin(self)
        self.painter.drawPixmap(self.rect(), self.pixmap.copy(self.btn_width * self.status, 0, self.btn_width, self.btn_height))
        self.painter.end()
コード例 #31
0
 def drawTextIcon(
     self,
     painter,
     image: QPixmap,
     shearX: float = 0,
     shearY: float = 0,
     iconX=0,
     iconY=0,
     textX=60,
     textY=21,
     fontSize=11,
 ):
     """ 绘制图标和文字 """
     painter.shear(shearX, shearY)
     # 绘制图标
     painter.drawPixmap(iconX, iconY, image.width(), image.height(), image)
     # 绘制文字
     if self.text():
         painter.setPen(QPen(Qt.black))
         painter.setFont(QFont("Microsoft YaHei", fontSize, 25))
         if self.objectName() not in ["myLoveButton", "playListButton"]:
             painter.drawText(textX, textY + 16, self.text())
         else:
             painter.drawText(textX, textY + 18, self.text())
コード例 #32
0
    def initUI(self, image):
        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)
        label = QLabel(self)
        pixmap = QPixmap(image)
        label.setPixmap(pixmap)
        self.resize(pixmap.width(), pixmap.height())

        button = QPushButton('I see positive', self)
        button.setToolTip('I see a fish')
        button.move(20, 70)
        button.clicked.connect(self.on_click)

        button = QPushButton('I see negative', self)
        button.setToolTip('This is an example button')
        button.move(150, 70)
        button.clicked.connect(self.on_click2)

        button = QPushButton('Exit', self)
        button.setToolTip('This is an example button')
        button.move(80, 200)
        button.clicked.connect(self.exit)

        self.show()
コード例 #33
0
    def place_minion(self, pos, tipo, size, iden, team):
        setattr(self, 'img_' + iden, MyQLabel(self))
        qlabel = getattr(self, 'img_' + iden)
        qlabel.tamano = size

        path = 'IMGS/{}/{}_move0.png'.format(tipo, team)
        if path not in self.imagenes:
            img = QPixmap(path)
            img = img.scaled(size, size, Qt.KeepAspectRatio)
            self.imagenes[path] = img
        else:
            img = self.imagenes[path]

        diag = (img.width()**2 + img.height()**2)**0.5
        qlabel.setMinimumSize(diag, diag)
        qlabel.setAlignment(Qt.AlignCenter)
        qlabel.setPixmap(img)
        qlabel.move(*pos)
        qlabel.show()

        setattr(self, 'emptylifebar_' + iden, MyQLabel(self))
        img = self.imagenes['IMGS/emptybar_minions.png']
        qlabel = getattr(self, 'emptylifebar_' + iden)
        qlabel.setPixmap(img)
        x, y = offsets[tipo]
        qlabel.offsets = (x, y)
        qlabel.move(pos[0] + x, pos[1] + y)
        qlabel.show()

        setattr(self, 'redbar_' + iden, MyQLabel(self))
        img = self.imagenes['IMGS/redbar_minions.png']
        qlabel = getattr(self, 'redbar_' + iden)
        qlabel.setPixmap(img)
        x, y = offsets[tipo]
        qlabel.move(pos[0] + x + 2, pos[1] + y + 2)
        qlabel.show()
コード例 #34
0
    def add_image(self, path: str, position: list, size: int) -> QLabel:
        """Add Image."""
        if os.path.isfile(path):
            labelImage = QLabel(self.window)
            pixmap = QPixmap(path)
            # ensures the new label size will scale the image itself
            labelImage.setScaledContents(True)
            labelImage.setPixmap(pixmap)
            width = pixmap.width()
            height = pixmap.height()

            if width > height:
                new_width = size
                new_height = size * height / width
            else:
                new_height = size
                new_width = size * width / height

            labelImage.resize(new_width, new_height)
            labelImage.move(position[0], position[1])

            self.images.append(labelImage)
            return labelImage
        raise Exception('Invalid path to image provided')
コード例 #35
0
ファイル: client.py プロジェクト: mmfallacy/Risci-MMR
 def __init__(self,
              resdir,
              width,
              height,
              toggle=True,
              tooltip=False,
              parent=None):
     super(ImageButton, self).__init__(parent)
     self.isHover = False
     self._states = []
     self.currentState = 0
     if toggle:
         tStates = 5
     else:
         tStates = 4
     for i in range(1, tStates):
         if os.path.isfile(os.path.join(resdir, str(i) + ".png")):
             _pixmap = QPixmap(os.path.join(resdir, str(i) + ".png"))
             w = min(width, _pixmap.width())
             h = min(height, _pixmap.height())
             self._states.append(_pixmap.scaled(w, h, Qt.KeepAspectRatio))
     self.setFixedSize(width, height)
     if tooltip:
         self.setToolTip(tooltip)
コード例 #36
0
ファイル: main.py プロジェクト: prouget/Films-et-series
    def selectionChanged(self):
        row = self.tableWidget_T3.currentRow()
        g = self.tableWidget_T3.item(row, 2).text()
        d = tmdbConnect.movieDescription(g)
        self.label_Title_T3.setText(d[0])
        self.label_Year_T3.setText(d[1])

        if self.label_Description_T3.setText(d[2]) == '':
            print('Pas de description')
        else:
            self.label_Description_T3.setText(d[2])

        if d[3] == None:
            self.label_Poster_T3.clear()
            self.label_Poster_T3.setText("Pas d'image")
        else:
            url = 'https://image.tmdb.org/t/p/w185/' + d[3]
            data = urllib.request.urlopen(url).read()

            image = QtGui.QImage()
            image.loadFromData(data)
            pixmap = QPixmap(image)
            self.label_Poster_T3.setPixmap(pixmap)
            self.label_Poster_T3.resize(pixmap.width(), pixmap.height())
コード例 #37
0
    def _drawPixmap(self, role: Role, size: QSize) -> None:
        pixmap = QPixmap(size)
        width, height = pixmap.width(), pixmap.height()
        pixmap.fill(Qt.transparent)
        painter = QPainter()
        painter.begin(pixmap)
        painter.setRenderHint(QPainter.Antialiasing)

        if role == self.Role.CHECKED:
            self.drawPixmapForChecked(painter, width, height)
        elif role == self.Role.UNCHECKED:
            self.drawPixmapForUnchecked(painter, width, height)
        elif role == self.Role.PARTIAL:
            self.drawPixmapForPartiallyChecked(painter, width, height)
        elif role == self.Role.MODE_3D:
            self.drawPixmapFor3d(painter, width, height)
        elif role == self.Role.MODE_2D:
            self.drawPixmapFor2d(painter, width, height)
        elif role == self.Role.DISABLED:
            pixmap.fill(Qt.white)
        else:
            raise NotImplementedError(f"{role}")

        return pixmap
コード例 #38
0
class Resize(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        super().setupUi(self)
        self.btnEscolherArquivo.clicked.connect(self.open_image)
        self.btnRedimensionar.clicked.connect(self.resize_image)
        self.btnSalvar.clicked.connect(self.save)

    def open_image(self):
        image, _ = QFileDialog.getOpenFileName(
            self.centralwidget,
            "Open Image",
            "/home/anthrax/Pictures/",
            options=QFileDialog.DontUseNativeDialog,
        )
        self.inputAbrirArquivo.setText(image)
        self.original_img = QPixmap(image)
        self.labelImg.setPixmap(self.original_img)
        self.inputLargura.setText(str(self.original_img.width()))
        self.inputAltura.setText(str(self.original_img.height()))

    def resize_image(self):
        height = int(self.inputLargura.text())
        self.new_image = self.original_img.scaledToWidth(height)
        self.labelImg.setPixmap(self.new_image)
        self.inputLargura.setText(str(self.new_image.width()))
        self.inputAltura.setText(str(self.new_image.height()))

    def save(self):
        image, _ = QFileDialog.getSaveFileName(
            self.centralwidget,
            "Save Image",
            "/home/anthrax/Documents/",
            options=QFileDialog.DontUseNativeDialog,
        )
        self.new_image.save(image, "PNG")
コード例 #39
0
class QXImage(QFrame):
    def __init__(self, name, path, info, parent=None):
        super().__init__(parent=parent)
        self.name = name
        self.path = path
        self.info = info

        self.setupUI()

    def setupUI(self):
        self.hbox_layout = QHBoxLayout()
        self.setLayout(self.hbox_layout)

        self.label_main = QLabel(parent=self)
        self.image = QPixmap(self.path)
        self.label_main.setPixmap(self.image)
        self.hbox_layout.addWidget(self.label_main)

        self.label_name = QLabel(self.name)
        self.hbox_layout.addWidget(self.label_name)
        self.resize(self.image.width(), self.image.height())

    def getInfo(self):
        return self.info
コード例 #40
0
class Redimensionar(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        super().setupUi(self)
        self.btn_escolher_arquivo.clicked.connect(self.abrir_imagem)
        self.btn_redimensionar.clicked.connect(self.redimensionar)
        self.btn_salvar.clicked.connect(self.salver)

    def abrir_imagem(self):
        imagem, _ =QFileDialog.getOpenFileName(
            self.centralwidget,
            'Abrir Imagem',
            r'C:\Users\gusta\Pictures',
            options=QFileDialog.DontUseNativeDialog
        )
        self.input_abrir_arquivo.setText(imagem)
        self.original_img = QPixmap(imagem)
        self.label_img.setPixmap(self.original_img)
        self.input_largura.setText(str(self.original_img.width()))
        self.input_altura.setText(str(self.original_img.height()))

    def redimensionar(self):
        largura = int(self.input_largura.text())
        self.nova_imagem = self.original_img.scaledToWidth(largura)
        self.label_img.setPixmap(self.nova_imagem)
        self.input_largura.setText(str(self.nova_imagem.width()))
        self.input_altura.setText(str(self.nova_imagem.height()))

    def salver(self):
        imagem, _ = QFileDialog.getSaveFileName(
            self.centralwidget,
            'Salvar Imagem',
            r'C:\Users\gusta\Pictures',
            options=QFileDialog.DontUseNativeDialog
        )
        self.nova_imagem.save(imagem, 'PNG')
コード例 #41
0
class RedimensionarImagem(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        super().setupUi(self)
        self.btnEscolherArquivo.clicked.connect(self.abrir_imagem)
        self.btnRedimensionar.clicked.connect(self.redimensionar)
        self.btnSalvar.clicked.connect(self.salvar)

    def abrir_imagem(self):
        # _ -> descarta/desconsidera a váriavel/valor que seria atribuído ali
        imagem, _ = QFileDialog.getOpenFileName(
            self.centralwidget,
            'Abrir imagem',
            r'/home/luizotavio/Imagens/',  # r'' para não colocar 2 barras inv
            options=QFileDialog.DontUseNativeDialog  # talvez nem precise
        )
        self.inputAbrirArquivo.setText(imagem)  # nome dado no qt designer
        self.original_img = QPixmap(imagem)
        self.labelImg.setPixmap(self.original_img)
        self.inputLargura.setText(str(self.original_img.width()))
        self.inputAltura.setText(str(self.original_img.height()))

    def redimensionar(self):
        largura = int(self.inputLargura.text())
        self.nova_imagem = self.original_img.scaledToWidth(largura)
        self.labelImg.setPixmap(self.nova_imagem)
        self.inputLargura.setText(str(self.nova_imagem.width()))
        self.inputAltura.setText(str(self.nova_imagem.height()))

    def salvar(self):
        imagem, _ = QFileDialog.getSaveFileName(
            self.centralwidget,
            'Salvar imagem',
            r'/home/luizotavio/Desktop/',
            options=QFileDialog.DontUseNativeDialog)
        self.nova_imagem.save(imagem, 'PNG')
コード例 #42
0
ファイル: blue.py プロジェクト: Vladius25/BluePlayer
    def load_img(self, c):
        global counter
        counter += 1
        imager = Imager(self.state["Title"], self.state["Artist"])
        data = imager.get_data()

        if (c + 1 != counter):
            return

        pixmap = QPixmap()
        pixmap.loadFromData(data)

        map = QBitmap(pixmap.size())
        map.fill(Qt.color0)
        painter = QPainter(map)
        painter.setBrush(Qt.color1)
        painter.drawRoundedRect(0, 0, pixmap.width(), pixmap.height(), 10, 10)
        painter.end()

        self.app.label.setScaledContents(True)
        pixmap.setMask(map)
        self.app.label.setPixmap(
            pixmap.scaled(self.app.label.size(), QtCore.Qt.KeepAspectRatio,
                          QtCore.Qt.SmoothTransformation))
    def add_pic_fromData(self, data, boshowsize=True):
        if not data:
            return

        pixmap = None
        if isinstance(data, str):
            if os.path.isfile(data):
                pixmap = QPixmap(data)
        elif isinstance(data, bytes):
            pixmap = QPixmap()
            pixmap.loadFromData(data)
        if not pixmap:
            return
        icon = QIcon(pixmap)

        s_size = ''
        if boshowsize:
            s_size = '{}*{}'.format(pixmap.width(), pixmap.height())

        item = QListWidgetItem(icon, self.tr(s_size))
        item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
        item.setCheckState(Qt.Checked)
        self.addItem(item)
        self.scrollToItem(item)
コード例 #44
0
ファイル: xkcd.py プロジェクト: riher/xkcd-viewer
    def initUI(self):

        xkcd_array = requests.get("http://dynamic.xkcd.com/api-0/jsonp/comic/").json()

        self.setGeometry(300, 300, 1000, 500)
        title = xkcd_array['title'].encode("latin-1").decode("utf-8")
        self.setWindowTitle('XKCD - '+title)
        print(type(title))

        alt = xkcd_array['alt'].encode("latin-1").decode("utf-8")

        self.setToolTip(alt)

        url = xkcd_array['img']
        data = urllib.request.urlopen(url).read()
        img = QPixmap()
        img.loadFromData(data)

        self.resize(img.width(), img.height())

        lbl2 = QLabel('asd', self)
        lbl2.setPixmap(img)

        self.show()
コード例 #45
0
class Redimensionamento(QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        super().setupUi(self)  # para que ele execute a instancia dessa classe
        self.btnEscolheArq.clicked.connect(self.abrir_imagem)
        self.btnRedim.clicked.connect(self.redimensionar)
        self.btnSalvar.clicked.connect(self.salvar)

    def abrir_imagem(self):
        image, _ = QFileDialog.getOpenFileName(
            self.centralwidget,
            'Abrir imagem'
            '/home/adriana/Downloads/',
            # options=QFileDialog.DontUseNativeDialog  #se nao funcionar a janela, descomentar essa parte
        )
        self.inputArquivo.setText(image)
        self.original_img = QPixmap(image)
        self.labelImg.setPixmap(self.original_img)
        self.inputLargura.setText(str(self.original_img.width()))
        self.inputAltura.setText(str(self.original_img.height()))

    def redimensionar(self):
        largura = int(self.inputLargura.text())
        self.nova_imagem = self.original_img.scaledToWidth(
            largura)  # calcula a altura automaticamente
        self.labelImg.setPixmap(self.nova_imagem)
        self.inputLargura.setText(str(self.nova_imagem.width()))
        self.inputAltura.setText(str(self.nova_imagem.height()))

    def salvar(self):
        image, _ = QFileDialog.getSaveFileName(
            self.centralwidget,
            'Salvar imagem'
            '/home/adriana/',
        )
        self.nova_imagem.save(image)
コード例 #46
0
    def setBorderImage(self, obj, scale, source, repeat='stretched stretched'):
        # 获取图片尺寸
        sourcePixmap = QPixmap(source)
        sourceWidth = sourcePixmap.width()
        sourceHeight = sourcePixmap.height()
        # print(sourceHeight, sourceWidth)

        slice = [0, 0, 0, 0]
        slice[0] = scale[1]  # 上
        slice[1] = sourceWidth - scale[2]  # 右
        if slice[1] < 0:
            slice[1] = 0
        slice[2] = sourceHeight - scale[3]  # 下
        if slice[2] < 0:
            slice[2] = 0
        slice[3] = scale[0]  # 左

        slice = ' '.join([str(i) for i in slice])

        # print(slice)
        obj.setStyleSheet('padding:' + str(sourceHeight / 2) + ' -' +
                          str(sourceWidth / 2) + ';border-width:' + slice +
                          ';border-image:url(' + source + ') ' + slice + ' ' +
                          repeat)
コード例 #47
0
class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)

        self.puzzleImage = QPixmap()

        self.setupMenus()
        self.setupWidgets()

        self.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
        self.setWindowTitle("Puzzle")

    def openImage(self, path=None):
        if not path:
            path, _ = QFileDialog.getOpenFileName(
                self, "Open Image", '', "Image Files (*.png *.jpg *.bmp)")

        if path:
            newImage = QPixmap()
            if not newImage.load(path):
                QMessageBox.warning(self, "Open Image",
                                    "The image file could not be loaded.",
                                    QMessageBox.Cancel)
                return

            self.puzzleImage = newImage
            self.setupPuzzle()

    def setCompleted(self):
        QMessageBox.information(
            self, "Puzzle Completed",
            "Congratulations! You have completed the puzzle!\nClick OK "
            "to start again.", QMessageBox.Ok)

        self.setupPuzzle()

    def setupPuzzle(self):
        size = min(self.puzzleImage.width(), self.puzzleImage.height())
        self.puzzleImage = self.puzzleImage.copy(
            (self.puzzleImage.width() - size) / 2,
            (self.puzzleImage.height() - size) / 2, size,
            size).scaled(400, 400, Qt.IgnoreAspectRatio,
                         Qt.SmoothTransformation)

        self.piecesList.clear()

        for y in range(5):
            for x in range(5):
                pieceImage = self.puzzleImage.copy(x * 80, y * 80, 80, 80)
                self.piecesList.addPiece(pieceImage, QPoint(x, y))

        random.seed(QCursor.pos().x() ^ QCursor.pos().y())

        for i in range(self.piecesList.count()):
            if random.random() < 0.5:
                item = self.piecesList.takeItem(i)
                self.piecesList.insertItem(0, item)

        self.puzzleWidget.clear()

    def setupMenus(self):
        fileMenu = self.menuBar().addMenu("&File")

        openAction = fileMenu.addAction("&Open...")
        openAction.setShortcut("Ctrl+O")

        exitAction = fileMenu.addAction("E&xit")
        exitAction.setShortcut("Ctrl+Q")

        gameMenu = self.menuBar().addMenu("&Game")

        restartAction = gameMenu.addAction("&Restart")

        openAction.triggered.connect(self.openImage)
        exitAction.triggered.connect(QApplication.instance().quit)
        restartAction.triggered.connect(self.setupPuzzle)

    def setupWidgets(self):
        frame = QFrame()
        frameLayout = QHBoxLayout(frame)

        self.piecesList = PiecesList()

        self.puzzleWidget = PuzzleWidget()

        self.puzzleWidget.puzzleCompleted.connect(self.setCompleted,
                                                  Qt.QueuedConnection)

        frameLayout.addWidget(self.piecesList)
        frameLayout.addWidget(self.puzzleWidget)
        self.setCentralWidget(frame)
コード例 #48
0
ファイル: mandelbrot.py プロジェクト: death-finger/Scripts
class MandelbrotWidget(QWidget):
    def __init__(self, parent=None):
        super(MandelbrotWidget, self).__init__(parent)

        self.thread = RenderThread()
        self.pixmap = QPixmap()
        self.pixmapOffset = QPoint()
        self.lastDragPos = QPoint()

        self.centerX = DefaultCenterX
        self.centerY = DefaultCenterY
        self.pixmapScale = DefaultScale
        self.curScale = DefaultScale

        self.thread.renderedImage.connect(self.updatePixmap)

        self.setWindowTitle("Mandelbrot")
        self.setCursor(Qt.CrossCursor)
        self.resize(550, 400)

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.fillRect(self.rect(), Qt.black)

        if self.pixmap.isNull():
            painter.setPen(Qt.white)
            painter.drawText(self.rect(), Qt.AlignCenter,
                    "Rendering initial image, please wait...")
            return

        if self.curScale == self.pixmapScale:
            painter.drawPixmap(self.pixmapOffset, self.pixmap)
        else:
            scaleFactor = self.pixmapScale / self.curScale
            newWidth = int(self.pixmap.width() * scaleFactor)
            newHeight = int(self.pixmap.height() * scaleFactor)
            newX = self.pixmapOffset.x() + (self.pixmap.width() - newWidth) / 2
            newY = self.pixmapOffset.y() + (self.pixmap.height() - newHeight) / 2

            painter.save()
            painter.translate(newX, newY)
            painter.scale(scaleFactor, scaleFactor)
            exposed, _ = painter.matrix().inverted()
            exposed = exposed.mapRect(self.rect()).adjusted(-1, -1, 1, 1)
            painter.drawPixmap(exposed, self.pixmap, exposed)
            painter.restore()

        text = "Use mouse wheel or the '+' and '-' keys to zoom. Press and " \
                "hold left mouse button to scroll."
        metrics = painter.fontMetrics()
        textWidth = metrics.width(text)

        painter.setPen(Qt.NoPen)
        painter.setBrush(QColor(0, 0, 0, 127))
        painter.drawRect((self.width() - textWidth) / 2 - 5, 0, textWidth + 10,
                metrics.lineSpacing() + 5)
        painter.setPen(Qt.white)
        painter.drawText((self.width() - textWidth) / 2,
                metrics.leading() + metrics.ascent(), text)

    def resizeEvent(self, event):
        self.thread.render(self.centerX, self.centerY, self.curScale,
                self.size())

    def keyPressEvent(self, event):
        if event.key() == Qt.Key_Plus:
            self.zoom(ZoomInFactor)
        elif event.key() == Qt.Key_Minus:
            self.zoom(ZoomOutFactor)
        elif event.key() == Qt.Key_Left:
            self.scroll(-ScrollStep, 0)
        elif event.key() == Qt.Key_Right:
            self.scroll(+ScrollStep, 0)
        elif event.key() == Qt.Key_Down:
            self.scroll(0, -ScrollStep)
        elif event.key() == Qt.Key_Up:
            self.scroll(0, +ScrollStep)
        else:
            super(MandelbrotWidget, self).keyPressEvent(event)

    def wheelEvent(self, event):
        numDegrees = event.angleDelta().y() / 8
        numSteps = numDegrees / 15.0
        self.zoom(pow(ZoomInFactor, numSteps))

    def mousePressEvent(self, event):
        if event.buttons() == Qt.LeftButton:
            self.lastDragPos = QPoint(event.pos())

    def mouseMoveEvent(self, event):
        if event.buttons() & Qt.LeftButton:
            self.pixmapOffset += event.pos() - self.lastDragPos
            self.lastDragPos = QPoint(event.pos())
            self.update()

    def mouseReleaseEvent(self, event):
        if event.button() == Qt.LeftButton:
            self.pixmapOffset += event.pos() - self.lastDragPos
            self.lastDragPos = QPoint()

            deltaX = (self.width() - self.pixmap.width()) / 2 - self.pixmapOffset.x()
            deltaY = (self.height() - self.pixmap.height()) / 2 - self.pixmapOffset.y()
            self.scroll(deltaX, deltaY)

    def updatePixmap(self, image, scaleFactor):
        if not self.lastDragPos.isNull():
            return

        self.pixmap = QPixmap.fromImage(image)
        self.pixmapOffset = QPoint()
        self.lastDragPosition = QPoint()
        self.pixmapScale = scaleFactor
        self.update()

    def zoom(self, zoomFactor):
        self.curScale *= zoomFactor
        self.update()
        self.thread.render(self.centerX, self.centerY, self.curScale,
                self.size())

    def scroll(self, deltaX, deltaY):
        self.centerX += deltaX * self.curScale
        self.centerY += deltaY * self.curScale
        self.update()
        self.thread.render(self.centerX, self.centerY, self.curScale,
                self.size())
コード例 #49
0
ファイル: IntroScreen.py プロジェクト: zuccbae/assistive-gui
import sys
from PyQt5.QtWidgets import QApplication, QLabel, QWidget
from PyQt5.QtCore import Qt, QTimer
from PyQt5.QtGui import QIcon, QPixmap

app = QApplication(sys.argv)

label = QLabel(app)
pixmap = QPixmap('EYE.jpg')
label.setPixmap(pixmap)
label.resize(pixmap.width(), pixmap.height())
label.setWindowFlags(Qt.SplashScreen | Qt.FramelessWindowHint)
label.show()

QTimer.singleShot(8000, app.quit)

sys.exit(app.exec_())
コード例 #50
0
ファイル: gallery.py プロジェクト: ImoutoChan/happypanda
class GridDelegate(QStyledItemDelegate):
	"A custom delegate for the model/view framework"

	POPUP = pyqtSignal()
	CONTEXT_ON = False

	# Gallery states
	G_NORMAL, G_DOWNLOAD = range(2)

	def __init__(self, parent=None):
		super().__init__(parent)
		QPixmapCache.setCacheLimit(app_constants.THUMBNAIL_CACHE_SIZE[0]*
							 app_constants.THUMBNAIL_CACHE_SIZE[1])
		self._painted_indexes = {}

		#misc.FileIcon.refresh_default_icon()
		self.file_icons = misc.FileIcon()
		if app_constants.USE_EXTERNAL_VIEWER:
			self.external_icon = self.file_icons.get_external_file_icon()
		else:
			self.external_icon = self.file_icons.get_default_file_icon()

		self.font_size = app_constants.GALLERY_FONT[1]
		self.font_name =0 # app_constants.GALLERY_FONT[0]
		if not self.font_name:
			self.font_name = QWidget().font().family()
		self.title_font = QFont()
		self.title_font.setBold(True)
		self.title_font.setFamily(self.font_name)
		self.artist_font = QFont()
		self.artist_font.setFamily(self.font_name)
		if self.font_size is not 0:
			self.title_font.setPixelSize(self.font_size)
			self.artist_font.setPixelSize(self.font_size)
		self.title_font_m = QFontMetrics(self.title_font)
		self.artist_font_m = QFontMetrics(self.artist_font)
		t_h = self.title_font_m.height()
		a_h = self.artist_font_m.height()
		self.text_label_h = a_h + t_h * 2
		self.W = app_constants.THUMB_W_SIZE
		self.H = app_constants.THUMB_H_SIZE + app_constants.GRIDBOX_LBL_H#self.text_label_h #+ app_constants.GRIDBOX_LBL_H

	def key(self, key):
		"Assigns an unique key to indexes"
		if key in self._painted_indexes:
			return self._painted_indexes[key]
		else:
			k = hash(key)
			self._painted_indexes[key] = str(k)
			return str(k)

	def paint(self, painter, option, index):
		assert isinstance(painter, QPainter)
		if index.data(Qt.UserRole+1):
			if app_constants.HIGH_QUALITY_THUMBS:
				painter.setRenderHint(QPainter.SmoothPixmapTransform)
			painter.setRenderHint(QPainter.Antialiasing)
			gallery = index.data(Qt.UserRole+1)
			title = gallery.title
			artist = gallery.artist
			title_color = app_constants.GRID_VIEW_TITLE_COLOR
			artist_color = app_constants.GRID_VIEW_ARTIST_COLOR
			label_color = app_constants.GRID_VIEW_LABEL_COLOR
			# Enable this to see the defining box
			#painter.drawRect(option.rect)
			# define font size
			if 20 > len(title) > 15:
				title_size = "font-size:{}px;".format(self.font_size)
			elif 30 > len(title) > 20:
				title_size = "font-size:{}px;".format(self.font_size-1)
			elif 40 > len(title) >= 30:
				title_size = "font-size:{}px;".format(self.font_size-2)
			elif 50 > len(title) >= 40:
				title_size = "font-size:{}px;".format(self.font_size-3)
			elif len(title) >= 50:
				title_size = "font-size:{}px;".format(self.font_size-4)
			else:
				title_size = "font-size:{}px;".format(self.font_size)

			if 30 > len(artist) > 20:
				artist_size = "font-size:{}px;".format(self.font_size)
			elif 40 > len(artist) >= 30:
				artist_size = "font-size:{}px;".format(self.font_size-1)
			elif len(artist) >= 40:
				artist_size = "font-size:{}px;".format(self.font_size-2)
			else:
				artist_size = "font-size:{}px;".format(self.font_size)

			#painter.setPen(QPen(Qt.NoPen))
			#option.rect = option.rect.adjusted(11, 10, 0, 0)
			option.rect.setWidth(self.W)

			option.rect.setHeight(self.H)
			rec = option.rect.getRect()
			x = rec[0]
			y = rec[1]
			w = rec[2]
			h = rec[3]

			text_area = QTextDocument()
			text_area.setDefaultFont(option.font)
			text_area.setHtml("""
			<head>
			<style>
			#area
			{{
				display:flex;
				width:{6}px;
				height:{7}px
			}}
			#title {{
			position:absolute;
			color: {4};
			font-weight:bold;
			{0}
			}}
			#artist {{
			position:absolute;
			color: {5};
			top:20px;
			right:0;
			{1}
			}}
			</style>
			</head>
			<body>
			<div id="area">
			<center>
			<div id="title">{2}
			</div>
			<div id="artist">{3}
			</div>
			</div>
			</center>
			</body>
			""".format(title_size, artist_size, title, artist, title_color, artist_color,
			  130+app_constants.SIZE_FACTOR, 1+app_constants.SIZE_FACTOR))
			text_area.setTextWidth(w)

			#chapter_area = QTextDocument()
			#chapter_area.setDefaultFont(option.font)
			#chapter_area.setHtml("""
			#<font color="black">{}</font>
			#""".format("chapter"))
			#chapter_area.setTextWidth(w)
			def center_img(width):
				new_x = x
				if width < w:
					diff = w - width
					offset = diff//2
					new_x += offset
				return new_x

			def img_too_big(start_x):
				txt_layout = misc.text_layout("Image is too big!", w, self.title_font, self.title_font_m)

				clipping = QRectF(x, y+h//4, w, app_constants.GRIDBOX_LBL_H - 10)
				txt_layout.draw(painter, QPointF(x, y+h//4),
					  clip=clipping)

			# if we can't find a cached image
			pix_cache = QPixmapCache.find(self.key(gallery.profile))
			if isinstance(pix_cache, QPixmap):
				self.image = pix_cache
				img_x = center_img(self.image.width())
				if self.image.width() > w or self.image.height() > h:
					img_too_big(img_x)
				else:
					if self.image.height() < self.image.width(): #to keep aspect ratio
						painter.drawPixmap(QPoint(img_x,y),
								self.image)
					else:
						painter.drawPixmap(QPoint(img_x,y),
								self.image)
			else:
				self.image = QPixmap(gallery.profile)
				img_x = center_img(self.image.width())
				QPixmapCache.insert(self.key(gallery.profile), self.image)
				if self.image.width() > w or self.image.height() > h:
					img_too_big(img_x)
				else:
					if self.image.height() < self.image.width(): #to keep aspect ratio
						painter.drawPixmap(QPoint(img_x,y),
								self.image)
					else:
						painter.drawPixmap(QPoint(img_x,y),
								self.image)

			# draw ribbon type
			painter.save()
			painter.setPen(Qt.NoPen)
			if app_constants.DISPLAY_GALLERY_RIBBON:
				type_ribbon_w = type_ribbon_l = w*0.11
				rib_top_1 = QPointF(x+w-type_ribbon_l-type_ribbon_w, y)
				rib_top_2 = QPointF(x+w-type_ribbon_l, y)
				rib_side_1 = QPointF(x+w, y+type_ribbon_l)
				rib_side_2 = QPointF(x+w, y+type_ribbon_l+type_ribbon_w)
				ribbon_polygon = QPolygonF([rib_top_1, rib_top_2, rib_side_1, rib_side_2])
				ribbon_path = QPainterPath()
				ribbon_path.setFillRule(Qt.WindingFill)
				ribbon_path.addPolygon(ribbon_polygon)
				ribbon_path.closeSubpath()
				painter.setBrush(QBrush(QColor(self._ribbon_color(gallery.type))))
				painter.drawPath(ribbon_path)

			# draw if favourited
			if gallery.fav == 1:
				star_ribbon_w = star_ribbon_l = w*0.08
				rib_top_1 = QPointF(x+star_ribbon_l, y)
				rib_side_1 = QPointF(x, y+star_ribbon_l)
				rib_top_2 = QPointF(x+star_ribbon_l+star_ribbon_w, y)
				rib_side_2 = QPointF(x, y+star_ribbon_l+star_ribbon_w)
				rib_star_mid_1 = QPointF((rib_top_1.x()+rib_side_1.x())/2, (rib_top_1.y()+rib_side_1.y())/2)
				rib_star_factor = star_ribbon_l/4
				rib_star_p1_1 = rib_star_mid_1 + QPointF(rib_star_factor, -rib_star_factor)
				rib_star_p1_2 = rib_star_p1_1 + QPointF(-rib_star_factor, -rib_star_factor)
				rib_star_p1_3 = rib_star_mid_1 + QPointF(-rib_star_factor, rib_star_factor)
				rib_star_p1_4 = rib_star_p1_3 + QPointF(-rib_star_factor, -rib_star_factor)

				crown_1 = QPolygonF([rib_star_p1_1, rib_star_p1_2, rib_star_mid_1, rib_star_p1_4, rib_star_p1_3])
				painter.setBrush(QBrush(QColor("yellow")))
				painter.drawPolygon(crown_1)

				ribbon_polygon = QPolygonF([rib_top_1, rib_side_1, rib_side_2, rib_top_2])
				ribbon_path = QPainterPath()
				ribbon_path.setFillRule(Qt.WindingFill)
				ribbon_path.addPolygon(ribbon_polygon)
				ribbon_path.closeSubpath()
				painter.drawPath(ribbon_path)
				#painter.setPen(QColor("#d35400"))
				#painter.drawPolyline(rib_top_1, rib_star_p1_1, rib_star_p1_2, rib_star_mid_1, rib_star_p1_4, rib_star_p1_3, rib_side_1)
				#painter.drawLine(rib_top_1, rib_top_2)
				#painter.drawLine(rib_top_2, rib_side_2)
				#painter.drawLine(rib_side_1, rib_side_2)
			painter.restore()
			
			if app_constants._REFRESH_EXTERNAL_VIEWER:
				if app_constants.USE_EXTERNAL_VIEWER:
					self.external_icon = self.file_icons.get_external_file_icon()
				else:
					self.external_icon = self.file_icons.get_default_file_icon()
			
			if gallery.state == self.G_DOWNLOAD:
				painter.save()
				dl_box = QRect(x, y, w, 20)
				painter.setBrush(QBrush(QColor(0,0,0,123)))
				painter.setPen(QColor('white'))
				painter.drawRect(dl_box)
				painter.drawText(dl_box, Qt.AlignCenter, 'Downloading...')
				painter.restore()
			else:
				if app_constants.DISPLAY_GALLERY_TYPE:
					self.type_icon = self.file_icons.get_file_icon(gallery.path)
					if self.type_icon and not self.type_icon.isNull():
						self.type_icon.paint(painter, QRect(x+2, y+app_constants.THUMB_H_SIZE-16, 16, 16))

				if app_constants.USE_EXTERNAL_PROG_ICO:
					if self.external_icon and not self.external_icon.isNull():
						self.external_icon.paint(painter, QRect(x+w-30, y+app_constants.THUMB_H_SIZE-28, 28, 28))

			def draw_text_label(lbl_h):
				#draw the label for text
				painter.save()
				painter.translate(x, y+app_constants.THUMB_H_SIZE)
				box_color = QBrush(QColor(label_color))#QColor(0,0,0,123))
				painter.setBrush(box_color)
				rect = QRect(0, 0, w, lbl_h) #x, y, width, height
				painter.fillRect(rect, box_color)
				painter.restore()
				return rect

			if option.state & QStyle.State_MouseOver or\
			    option.state & QStyle.State_Selected:
				title_layout = misc.text_layout(title, w, self.title_font, self.title_font_m)
				artist_layout = misc.text_layout(artist, w, self.artist_font, self.artist_font_m)
				t_h = title_layout.boundingRect().height()
				a_h = artist_layout.boundingRect().height()

				if app_constants.GALLERY_FONT_ELIDE:
					lbl_rect = draw_text_label(min(t_h+a_h+3, app_constants.GRIDBOX_LBL_H))
				else:
					lbl_rect = draw_text_label(app_constants.GRIDBOX_LBL_H)

				clipping = QRectF(x, y+app_constants.THUMB_H_SIZE, w, app_constants.GRIDBOX_LBL_H - 10)
				painter.setPen(QColor(title_color))
				title_layout.draw(painter, QPointF(x, y+app_constants.THUMB_H_SIZE),
					  clip=clipping)
				painter.setPen(QColor(artist_color))
				artist_layout.draw(painter, QPointF(x, y+app_constants.THUMB_H_SIZE+t_h),
					   clip=clipping)
				#painter.fillRect(option.rect, QColor)
			else:
				if app_constants.GALLERY_FONT_ELIDE:
					lbl_rect = draw_text_label(self.text_label_h)
				else:
					lbl_rect = draw_text_label(app_constants.GRIDBOX_LBL_H)
				# draw text
				painter.save()
				alignment = QTextOption(Qt.AlignCenter)
				alignment.setUseDesignMetrics(True)
				title_rect = QRectF(0,0,w, self.title_font_m.height())
				artist_rect = QRectF(0,self.artist_font_m.height(),w,
						 self.artist_font_m.height())
				painter.translate(x, y+app_constants.THUMB_H_SIZE)
				if app_constants.GALLERY_FONT_ELIDE:
					painter.setFont(self.title_font)
					painter.setPen(QColor(title_color))
					painter.drawText(title_rect,
							 self.title_font_m.elidedText(title, Qt.ElideRight, w-10),
							 alignment)
				
					painter.setPen(QColor(artist_color))
					painter.setFont(self.artist_font)
					alignment.setWrapMode(QTextOption.NoWrap)
					painter.drawText(artist_rect,
								self.title_font_m.elidedText(artist, Qt.ElideRight, w-10),
								alignment)
				else:
					text_area.setDefaultFont(QFont(self.font_name))
					text_area.drawContents(painter)
				##painter.resetTransform()
				painter.restore()

			if option.state & QStyle.State_Selected:
				painter.save()
				selected_rect = QRectF(x, y, w, lbl_rect.height()+app_constants.THUMB_H_SIZE)
				painter.setPen(Qt.NoPen)
				painter.setBrush(QBrush(QColor(164,164,164,120)))
				painter.drawRoundedRect(selected_rect, 5, 5)
				#painter.fillRect(selected_rect, QColor(164,164,164,120))
				painter.restore()

			if gallery.dead_link:
				painter.save()
				selected_rect = QRectF(x, y, w, lbl_rect.height()+app_constants.THUMB_H_SIZE)
				painter.setPen(Qt.NoPen)
				painter.setBrush(QBrush(QColor(255,0,0,120)))
				p_path = QPainterPath()
				p_path.setFillRule(Qt.WindingFill)
				p_path.addRoundedRect(selected_rect, 5,5)
				p_path.addRect(x,y, 20, 20)
				p_path.addRect(x+w-20,y, 20, 20)
				painter.drawPath(p_path.simplified())
				painter.setPen(QColor("white"))
				txt_layout = misc.text_layout("Cannot find gallery source!", w, self.title_font, self.title_font_m)
				txt_layout.draw(painter, QPointF(x, y+h*0.3))
				painter.restore()

			if app_constants.DEBUG:
				painter.save()
				painter.setBrush(QBrush(QColor("red")))
				painter.setPen(QColor("white"))
				txt_l = self.title_font_m.width(str(gallery.id))
				painter.drawRect(x, y+40, txt_l*2, self.title_font_m.height())
				painter.drawText(x+1, y+51, str(gallery.id))
				painter.restore()
			if option.state & QStyle.State_Selected:
				painter.setPen(QPen(option.palette.highlightedText().color()))
		else:
			super().paint(painter, option, index)

	def _ribbon_color(self, gallery_type):
		if gallery_type:
			gallery_type = gallery_type.lower()
		if gallery_type == "manga":
			return app_constants.GRID_VIEW_T_MANGA_COLOR
		elif gallery_type == "doujinshi":
			return app_constants.GRID_VIEW_T_DOUJIN_COLOR
		elif "artist cg" in gallery_type:
			return app_constants.GRID_VIEW_T_ARTIST_CG_COLOR
		elif "game cg" in gallery_type:
			return app_constants.GRID_VIEW_T_GAME_CG_COLOR
		elif gallery_type == "western":
			return app_constants.GRID_VIEW_T_WESTERN_COLOR
		elif "image" in gallery_type:
			return app_constants.GRID_VIEW_T_IMAGE_COLOR
		elif gallery_type == "non-h":
			return app_constants.GRID_VIEW_T_NON_H_COLOR
		elif gallery_type == "cosplay":
			return app_constants.GRID_VIEW_T_COSPLAY_COLOR
		else:
			return app_constants.GRID_VIEW_T_OTHER_COLOR

	def sizeHint(self, option, index):
		return QSize(self.W, self.H)
コード例 #51
0
class MyApp(QWidget):
    def __init__(self, parent=None):
        super().__init__()
        self.initUI()
        self.lb_1 = QLabel()

    def initUI(self):
        grid = QGridLayout()
        self.setLayout(grid)

        # option 정하기
        # 1열
        self.checkbox1 = QCheckBox('Resize')
        self.checkbox2 = QCheckBox('rotate')
        self.checkbox3 = QCheckBox('hfip')
        self.checkbox4 = QCheckBox('vfip')
        self.checkbox5 = QCheckBox('rename')

        # pixmap 추가한내용
        self.pixmap = QPixmap('/home/cj/Downloads/save.png')
        self.lbl_img = QLabel()
        self.lbl_img.setPixmap(self.pixmap)
        self.lbl_size = QLabel('Width: ' + str(self.pixmap.width()) +
                               ', Height: ' + str(self.pixmap.height()))
        self.lbl_size.setAlignment(Qt.AlignCenter)

        grid.addWidget(self.checkbox1, 0, 0)
        self.checkbox1.stateChanged.connect(self.image_resize)
        grid.addWidget(self.checkbox2, 1, 0)
        self.checkbox2.stateChanged.connect(self.image_rotation)
        grid.addWidget(self.checkbox3, 2, 0)
        self.checkbox3.stateChanged.connect(self.image_hflip)
        grid.addWidget(self.checkbox4, 3, 0)
        self.checkbox4.stateChanged.connect(self.image_vflip)
        grid.addWidget(self.checkbox5, 4, 0)
        self.checkbox5.stateChanged.connect(self.image_rename)
        grid.addWidget(QLabel('PATH'), 6, 0)
        grid.addWidget(self.lbl_img, 7, 0)

        # 2열
        self.ReSize_A = QLineEdit()
        self.ReSize_A.setAcceptDrops(False)
        grid.addWidget(self.ReSize_A, 0, 1)
        self.ReSize_A.returnPressed.connect(self.input_mask_changed)

        self.RoTate = QLineEdit()
        self.RoTate.setAcceptDrops(False)
        grid.addWidget(self.RoTate, 1, 1)
        self.RoTate.returnPressed.connect(self.input_mask_change2)

        grid.addWidget(QLabel('prefix'), 4, 1)
        self.prefix = QLineEdit()
        self.prefix.setAcceptDrops(False)
        grid.addWidget(self.prefix, 5, 1)
        self.prefix.returnPressed.connect(self.image_show)

        self.path = QLineEdit()
        self.path.setAcceptDrops(False)
        grid.addWidget(self.path, 6, 1, 1, 3)
        self.path.returnPressed.connect(self.image_show)

        # 3열
        grid.addWidget(QLabel('number'), 5, 2)

        # 4열
        self.btn = QPushButton('RUN')
        self.btn.clicked.connect(self.image_show)
        grid.addWidget(self.btn, 0, 3, 3, 1)  # 크기 수정해야함
        grid.addWidget(QLabel('suffix'), 4, 3)
        self.suffix = QLineEdit()
        grid.addWidget(self.suffix, 5, 3)

        self.setWindowTitle('Type Here')
        self.setGeometry(300, 300, 480, 320)
        self.show()

    def image_show(self):
        self.search_image = '/home/cj/Downloads/' + self.path.text()
        self.pixmap = QPixmap(self.search_image)
        self.lbl_size = QLabel('Width: ' + str(self.pixmap.width()) +
                               ', Height: ' + str(self.pixmap.height()))
        self.lbl_size.setAlignment(Qt.AlignCenter)

        #click 시 checkbox 확인인
        #사이즈 수정
        if self.checkbox1.isChecked() == True:
            ##pixmap + cv2 활용
            img = cv2.imread(self.search_image)
            reresize = float(self.ReSize_A.text())
            self.resize_Img = cv2.resize(img,
                                         dsize=(0, 0),
                                         fx=reresize,
                                         fy=reresize,
                                         interpolation=cv2.INTER_LINEAR)
            cv2.imwrite("test.jpg", self.resize_Img)
            self.pixmap.load("test.jpg")

        # 각도회전
        if self.checkbox2.isChecked() == True:
            src = cv2.imread(self.search_image, cv2.IMREAD_COLOR)
            height, width, channel = src.shape
            rorotation = float(self.RoTate.text())
            matrix = cv2.getRotationMatrix2D((width / 2, height / 2),
                                             rorotation, 1)
            rotation_Img = cv2.warpAffine(src, matrix, (width, height))
            cv2.imwrite("rotation.jpg", rotation_Img)
            self.pixmap.load("rotation.jpg")

        if self.checkbox3.isChecked() == True:
            im = cv2.imread(self.search_image)
            # im2 = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
            im2_hflip = cv2.flip(im, 0)
            cv2.imwrite("im_hflip.jpg", im2_hflip)
            self.pixmap.load("im_hflip.jpg")

        if self.checkbox4.isChecked() == True:
            im = cv2.imread(self.search_image)
            im_vflip = cv2.flip(im, 1)
            cv2.imwrite("im_vflip.jpg", im_vflip)
            self.pixmap.load("im_vflip.jpg")

        if self.checkbox5.isChecked() == True:
            print('checkbox5 click')
            self.savefile()

        self.lbl_img.setPixmap(self.pixmap)  # 이미지 보여주는 줄
        print('run click')

# 사이즈 수정함수

    def image_resize(self):
        if self.checkbox1.isChecked() == True:
            self.input_mask_changed()

    def input_mask_changed(self):
        self.ReSize_A.setInputMask('0.0')
# 사진 각도변경

    def image_rotation(self):
        if self.checkbox2.isChecked() == True:
            self.input_mask_change2()

    def input_mask_change2(self):
        self.RoTate.setInputMask('000')
# hflip 함수

    def image_hflip(self):
        print('hflip click')
# vflip 함수

    def image_vflip(self):
        print('vflip click2')

# rename 함수

    def image_rename(self):
        print('rename click')

    def savefile(self):
        self.search_image = '/home/cj/Downloads/'
        name, _ = QFileDialog.getSaveFileName(
            self, self.search_image, options=QFileDialog.DontUseNativeDialog)
        cv2.imwrite(name, self.resize_Img)
コード例 #52
0
ファイル: Workspace.py プロジェクト: ariaaan/pi-utils
class Scene(QGraphicsScene):

    _bbox_pen = None
    _bbox_start_pos = None
    _default_class = None
    _guide_pen = None
    _image = None
    _img_h = None
    _img_w = None
    _label_path = None
    _model = None
    _mouse_pos = None

    def __init__(self, parent):
        super().__init__(parent)
        self._guide_pen = QPen(Qt.black, 1)
        self.setDefaultClass(0)

    def saveLabels(self):
        if self._label_path != None:

            if self._label_path.endswith(".jpg.txt"):
                self._label_path = self._label_path[:-8] + ".txt"

            lf = QSaveFile(self._label_path)
            if not lf.open(QIODevice.WriteOnly | QIODevice.Text):
                raise IOError('Cannot open "{}" for writing'.format(
                    self._label_path))

            for item in self.items():
                if item.type() == BBOX:
                    rect = item.rect()
                    c = item.number
                    x = (rect.x() + rect.width() / 2) / self._img_w
                    y = (rect.y() + rect.height() / 2) / self._img_h
                    w = rect.width() / self._img_w
                    h = rect.height() / self._img_h
                    line = '{c:d} {x:.10f} {y:.10f} {w:.10f} {h:.10f}\n'.format(
                        c=c, x=x, y=y, w=w, h=h)
                    lf.write(line.encode())

            if lf.commit():
                print('Wrote "{}"'.format(self._label_path))
            else:
                raise IOError('Cannot write "{}"'.format(self._label_path))

    def _addBBox(self, p1, p2, cls):
        rect = _mkRectF(p1, p2).intersected(QRectF(self._image.rect()))
        square = abs(rect.width() * rect.height())
        if square > 0.0:
            zvalue = 1.0 / square
            bbox = BoundingBoxItem(cls, rect, self._model)
            bbox.setZValue(zvalue)
            self.addItem(bbox)
            return True
        else:
            return False

    def _newBBox(self, p1, p2):
        if self._addBBox(p1, p2, self._default_class):
            self.invalidate()
            self.saveLabels()

    def setDefaultClass(self, cls):
        self._default_class = cls
        if self._model != None:
            (hue, sat, val) = self._model.hsvF(self._default_class)
            self._bbox_pen = QPen(QColor.fromHsvF(hue, sat, val), 2)

    def mouseMoveEvent(self, event):
        self._mouse_pos = event.scenePos()
        self.invalidate()
        super().mouseMoveEvent(event)

    def mousePressEvent(self, event):
        pos = event.scenePos()
        self._bbox_start_pos = pos

    def mouseReleaseEvent(self, event):
        if self._bbox_start_pos != None:
            self._newBBox(self._bbox_start_pos, event.scenePos())
            self._bbox_start_pos = None
            self._mouse_pos = None

    def mouseDoubleClickEvent(self, event):
        item = self.itemAt(event.scenePos(), QTransform())
        if item != None and item.type() == BBOX:
            self.removeItem(item)
            self.invalidate()
            self.saveLabels()

    def drawForeground(self, painter, rect):
        if self._mouse_pos != None:
            if self._bbox_start_pos == None:
                painter.setClipRect(rect)
                painter.setPen(self._guide_pen)
                painter.drawLine(self._mouse_pos.x(), rect.top(),
                                 self._mouse_pos.x(), rect.bottom())
                painter.drawLine(rect.left(), self._mouse_pos.y(),
                                 rect.right(), self._mouse_pos.y())
            else:
                painter.setPen(self._bbox_pen)
                painter.drawRect(
                    _mkRectF(self._bbox_start_pos, self._mouse_pos))

    def loadImage(self, image_path, label_path):
        self.clear()
        self._image = QPixmap(image_path)
        self._label_path = label_path[:-8] + ".txt"
        """
        if not label_path.endswith(".jpg.txt"):
            self._label_path = label_path[:-8] + ".txt"
        else:
            self._label_path = label_path
        """

        self.setSceneRect(QRectF(self._image.rect()))
        self.addPixmap(self._image)
        lines = []
        self._img_h = self._image.height()
        self._img_w = self._image.width()
        try:
            with open(self._label_path) as lbl:
                lines = lbl.readlines()
        except OSError as ex:
            if ex.errno != errno.ENOENT:
                raise

        for l in lines:
            m = labeler.BBOX_RE.match(l)
            if m != None:
                cls = int(m.group('cls'))
                x = float(m.group('x'))
                y = float(m.group('y'))
                h = float(m.group('h'))
                w = float(m.group('w'))
                p1 = QPointF((x - w / 2) * self._img_w,
                             (y - h / 2) * self._img_h)
                p2 = QPointF((x + w / 2) * self._img_w,
                             (y + h / 2) * self._img_h)
                self._addBBox(p1, p2, cls)
        self.invalidate()

    @property
    def model(self):
        return self._model

    def setModel(self, model):
        self._model = model
        self.setDefaultClass(0)
コード例 #53
0
class MainWindow(QMainWindow, Ui_MainWindow, QObject):
    all_points_given_signal = pyqtSignal(
    )  # Pravi se signal koji će biti korišćen da obavesti kada se unesu sve tačke

    def __init__(self, *args, **kwargs):
        super(MainWindow, self).__init__(*args, **kwargs)

        self.beforeDots = []  # Niz tačaka slike pre otklanjanja distorzije
        self.afterDots = []  # Niz tačaka druge slike

        self.num_of_dots = 0  # Broj tačaka koji će biti korišćen ( unosi korisnik )

        self.first = False
        self.second = False

        self.setupUi(self)

        self.original_file = ""

        self.imageBefore = QPixmap()  # Učitana slika čuva se kao mapa piksela
        self.imageAfter = QPixmap(
        )  # Slika koju pravi algoritam čuva se kao mapa piksela

        # Koriste se za crtanje tacaka na slikama
        self.painterBefore = QPainter()
        self.painterAfter = QPainter()

        self.init_gui()
        self.init_menu()

    def init_gui(self):
        self.labelBefore.setSizePolicy(QSizePolicy.Ignored,
                                       QSizePolicy.Ignored)
        self.labelAfter.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)

        self.labelBefore.mousePressEvent = self.get_pos
        self.labelAfter.mousePressEvent = self.get_pos

        self.get_num_of_dots()
        self.all_points_given_signal.connect(
            self.get_dots)  # Na signal poziva se funkcija get_dots
        self.loadButton.pressed.connect(
            self.load
        )  # Na klik na dugme "Učitaj sliku" poziva se funkcija load
        self.workButton.pressed.connect(
            self.work)  # Na klik na dugme "Primeni" poziva se funkcija work

    def init_menu(self):
        # Pritiskom na Esc ili u padajućem meniju na Izlaz izlazi se iz programa
        self.actionExit.triggered.connect(sys.exit)

        # Pritiskom na Ctrl + S ili u padajućem meniju na sačuvaj sliku čuva se slika dobijena iz algoritma
        self.actionSave.triggered.connect(self.save)

    def get_num_of_dots(self):
        num, ok = QInputDialog.getInt(
            self, "Broj tačaka",
            "Unesite broj tačaka koji će biti korišćen: ( >= 4 )")

        if ok and num >= 4:
            self.num_of_dots = num
        else:
            msg = QMessageBox()
            msg.setIcon(QMessageBox.Critical)
            msg.setWindowTitle("Greška")
            msg.setText("Broj tačaka mora biti >= 4!")
            msg.exec_()
            sys.exit()

    def load(self):
        file, _ = QFileDialog(self).getOpenFileName(self, "Open file", "",
                                                    "Image files (*.bmp)")

        filename, file_extension = os.path.splitext(file)
        if file_extension != ".bmp":
            msg = QMessageBox()
            msg.setIcon(QMessageBox.Critical)
            msg.setWindowTitle("Greška")
            msg.setText("Učitana slika mora biti u .bmp formatu!")
            msg.exec_()
            return

        self.imageBefore = QPixmap(
            filename)  # Učitava se slika kao mapa piksela
        self.original_file = filename

        if not self.imageBefore.isNull():
            # Postavlja se slika u okvir na prozoru za prikaz
            self.labelBefore.setPixmap(
                self.imageBefore.scaled(
                    QSize(self.labelBefore.width(),
                          self.labelBefore.height())))

            # Postavlja se da se slika uveličava i smanjuje sa labelom
            self.labelBefore.setScaledContents(True)

        # Pravi se crna slika koja će se upisati u okvir za novu sliku
        self.imageAfter = QPixmap(self.imageBefore.width(),
                                  self.imageBefore.height())
        self.imageAfter.fill(QColor("black"))

        self.labelAfter.setPixmap(
            self.imageAfter.scaled(
                QSize(self.labelAfter.width(), self.labelAfter.height())))

        # Postavlja se da se slika uveličava i smanjuje sa labelom
        self.labelAfter.setScaledContents(True)

        self.painterBefore = QPainter(self.imageBefore)
        self.painterBefore.setBrush(QBrush(Qt.blue))

        self.painterAfter = QPainter(self.imageAfter)
        self.painterAfter.setBrush(QBrush(Qt.red))

        self.first = True  # Omogučava se kliktanje po prvoj slici
        self.loadButton.setEnabled(False)
        self.get_dots()  # Poziva se funkcija za prikupljanje tačaka

    def get_dots(self):
        msg = QMessageBox()
        msg.setIcon(QMessageBox.Information)
        msg.setWindowTitle("Unos tačaka")

        # Ako je omogučeno kliktanje po prvoj slici
        if self.first:
            # Ovde se samo proverava broj tačaka da bi se gramatički tačno ispisala poruka :)
            if self.num_of_dots == 4:
                msg.setText("Unesite 4 tačke prve slike: ")
            else:
                msg.setText("Unesite " + str(self.num_of_dots) +
                            " tačaka prve slike: ")
            msg.exec_()

            self.label.setText(
                self.label.text() + "\n" +
                "- Tačke prve slike: ( Ispisuju se u odnosu na original )\n")
        # Ako je omogučeno kliktanje po drugoj a onemogućeno kliktanje po prvoj slici
        elif not self.first and self.second:
            # Ovde se samo proverava broj tačaka da bi se gramatički tačno ispisala poruka :)
            if self.num_of_dots == 4:
                msg.setText("Unesite 4 tačke druge slike: ")
            else:
                msg.setText("Unesite " + str(self.num_of_dots) +
                            " tačaka druge slike: ")
            msg.exec_()

            self.label.setText(
                self.label.text() + "\n" +
                "- Tačke druge slike: ( Ispisuju se u odnosu na original )\n")
        else:
            # Ako je unet dovoljan broj tačaka omogučava se dugme za primenu algoritama
            if len(self.beforeDots) == self.num_of_dots and len(
                    self.afterDots) == self.num_of_dots:
                self.workButton.setEnabled(True)
                self.painterAfter.end()

    def work(self):
        if self.naiveAlgorithm.isChecked():
            P = naive_algorithm(self.beforeDots, self.afterDots)
            P_inv = la.inv(P)
        elif self.dltAlgorithm.isChecked():
            P = show_dlt(self.beforeDots, self.afterDots)
            P_inv = la.inv(P)
        elif self.dltNormAlgorithm.isChecked():
            P = show_normalized(self.beforeDots, self.afterDots)
            P_inv = la.inv(P)
        else:
            msg = QMessageBox()
            msg.setIcon(QMessageBox.Critical)
            msg.setWindowTitle("Greška")
            msg.setText("Izaberite algoritam!")
            msg.exec_()
            return

        imgBefore = QImage(self.original_file)
        imgAfter = QPixmap(self.imageBefore.width(), self.imageBefore.height())
        imgAfter.fill(QColor("black"))
        imgAfter = imgAfter.toImage()

        for i in tqdm(range(imgBefore.width())):
            for j in range(imgBefore.height()):
                pixel = P_inv.dot(np.array([i, j, 1]))

                if pixel[0] < 0 or pixel[0] >= self.imageBefore.width():
                    continue

                if pixel[1] < 0 or pixel[1] >= self.imageBefore.height():
                    continue

                pix = imgBefore.pixelColor(pixel[0], pixel[1])
                imgAfter.setPixel(i, j, pix.rgb())

        self.imageAfter = QPixmap.fromImage(imgAfter)
        self.labelAfter.setPixmap(
            self.imageAfter.scaled(
                QSize(self.labelAfter.width(), self.labelAfter.height())))

        self.workButton.setEnabled(False)

    def get_pos(self, event):
        if self.first:
            x = event.pos().x()
            y = event.pos().y()

            # Skaliraju se koordinate da bi se dobile koordinate početne slike
            S_x = self.imageBefore.width() / self.labelBefore.width()
            x = x * S_x

            S_y = self.imageBefore.height() / self.labelBefore.height()
            y = y * S_y

            self.painterBefore.drawEllipse(x - 5, y - 5, 10, 10)

            self.labelBefore.setPixmap(
                self.imageBefore.scaled(
                    QSize(self.labelBefore.width(),
                          self.labelBefore.height())))

            self.beforeDots.append((x, y, 1))
            self.label.setText(self.label.text() + " " +
                               str((round(x), round(y))))
        elif self.second:
            x = event.pos().x()
            y = event.pos().y()

            # Skaliraju se koordinate da bi se dobile koordinate krajnje slike bez skaliranja da stane u prozor
            S_x = self.imageAfter.width() / self.labelAfter.width()
            x = x * S_x

            S_y = self.imageAfter.height() / self.labelAfter.height()
            y = y * S_y

            self.painterAfter.drawEllipse(x - 5, y - 5, 10, 10)
            self.labelAfter.setPixmap(
                self.imageAfter.scaled(
                    QSize(self.labelAfter.width(), self.labelAfter.height())))

            self.afterDots.append((x, y, 1))
            self.label.setText(self.label.text() + " " +
                               str((round(x), round(y))))

        # Ako se unese dovoljno prvih tačaka traži se isti broj drugih
        if len(self.beforeDots) == self.num_of_dots and self.first:
            self.first = False
            self.second = True
            self.labelBefore.mousePressEvent = self.empty_func
            self.all_points_given_signal.emit()

        if len(self.afterDots) == self.num_of_dots and self.second:
            self.second = False
            self.all_points_given_signal.emit()

    def empty_func(self, event):
        pass

    def save(self):
        # Čuva se dobijena slika
        file, file_type = QFileDialog(self).getSaveFileName(
            self, "Save file", "", "BMP (*.bmp);;PNG (*.png);;JPEG (*.jpeg)")

        filename, file_extension = os.path.splitext(file)

        if file_extension == "":
            if file_type == "BMP (*.bmp)":
                file_extension = ".bmp"
            elif file_type == "PNG (*.png)":
                file_extension = ".png"
            elif file_type == "JPEG (*.jpeg)":
                file_extension = ".jpeg"

        if file_extension == ".bmp" or file_extension == ".png" or file_extension == ".jpeg":
            self.imageAfter.save(file)

            QMessageBox.about(self, "Informacija", "Slika sačuvana.")
        else:
            QMessageBox.about(
                self, "Informacija",
                "Slika ne može biti sačuvana! ( Proveriti tip fajla... )")
コード例 #54
0
class mywindow(QtWidgets.QMainWindow):
 
	def __init__(self):

		super(mywindow, self).__init__()
		print(session.evaluate('''Directory[]'''))
		self.imageQuestion = False
		self.setFixedSize(1200,700)
		self.ui = Ui_MainWindow()
		self.ui.setupUi(self)
		self.white = False
		self.textcolor = "white"
		self.bg = self.palette().window().color()
		self.cl = (self.bg.redF(),self.bg.greenF(), self.bg.blueF()) # Makes the color of the textbox the same as the app
		if self.cl[0] > 0.5 and self.cl[1] > 0.5 and self.cl[2] >0.5:
			self.white = True
			self.textcolor = "black"

		# https://stackoverflow.com/questions/41247109/pyqt-how-to-switch-widgets-in-qstackedwidget
		# We can set up button functionality here instead.
		self.ui.toMainMenu.clicked.connect(self.refreshMenu)
		# then at either point regenerate the question by running the function

		# self.whatever.clicked.connect(self.newQuestion)
		self.ui.toMainMenu_2.clicked.connect(self.refreshMenu)
		self.ui.toMainMenu_3.clicked.connect(self.refreshMenu)

		self.ui.toSettings.clicked.connect(self.refreshSettings)

		self.ui.toQuestion.clicked.connect(self.newQuestion)
		self.ui.toQuestion_2.clicked.connect(self.deleteOldQuestion)

		self.ui.toAnswer.clicked.connect(lambda : self.ui.stackedWidget.setCurrentIndex(3))
		self.ui.difficultybox.addItems(["Easy","Normal","Hard"])
		topics=session.evaluate('''Keys[questionRepo["Easy"]]''')
		self.ui.topicbox.addItems(list(topics))

		# to access difficulty do self.ui.difficultybox.currentText()

	# For when you exit a menu and a question has been generated, this will remove the previous question and answer.
	def refresh(self):
		if self.ui.verticalLayout_5.count() < 2:
			return
		else:
			if self.ui.verticalLayout.count() == 3:
				self.ui.verticalLayout.removeWidget(self.label1)
				self.label1.deleteLater()
				self.label1 = None

			qBox = self.ui.verticalLayout_5.itemAt(1)
			self.ui.verticalLayout_5.removeItem(qBox)

			self.ui.verticalLayout.removeWidget(self.canvasA)
			self.canvasA.deleteLater()
			self.canvasA = None


	def refreshSettings(self):
		self.ui.stackedWidget.setCurrentIndex(1)
		self.refresh()

	def refreshMenu(self):
		self.ui.stackedWidget.setCurrentIndex(0)
		self.refresh()


	def newQuestion(self):

		topic=self.ui.topicbox.currentText()
		difficulty=self.ui.difficultybox.currentText()
		chk = session.evaluate(wlexpr('''TopicLength["'''+str(topic)+'''","'''+str(difficulty)+'''"]'''))
		if chk == 0:
			return
		self.ui.stackedWidget.setCurrentIndex(2) # Go to question menu


		qa=session.evaluate(wlexpr('''evalQuestion["'''+str(topic)+'''","'''+str(difficulty)+'''"]'''))
		q =qa[0]
		a=qa[1]
		img = qa[2]

		self.questionDisplay = QtWidgets.QHBoxLayout()
		self.questionDisplay.setObjectName("questionDisplay")
		spaceLeft= QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Minimum)
		self.questionDisplay.addItem(spaceLeft)

		self.question = Figure(facecolor=self.cl,edgecolor=self.cl)
		self.canvasQ = FigureCanvas(self.question)
		self.questionDisplay.addWidget(self.canvasQ)

		self.question.suptitle(q,
				x=0.0, y=0.5, 
				horizontalalignment='left',
				verticalalignment='bottom',
				fontsize=10,
				color=self.textcolor)

		self.canvasQ.draw()

		spaceRight = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Minimum)
		self.questionDisplay.addItem(spaceRight)
		self.ui.verticalLayout_5.addLayout(self.questionDisplay)		



		self.answer = Figure(facecolor=self.cl,edgecolor=self.cl)
		self.canvasA = FigureCanvas(self.answer)
		self.ui.verticalLayout.addWidget(self.canvasA)
		self.answer.suptitle(a,
				x=0.0, y=0.6, 
				horizontalalignment='left',
				verticalalignment='top',
				fontsize=10,
				color=self.textcolor)

		self.canvasA.draw()

		# Image handling, if there is a 0 that means there is no image, otherwise do:
		if img != 0:
			self.imageQuestion = True
			self.label1 = QtWidgets.QLabel(self)
			self.pixmap1 = QPixmap(img)
			self.label1.setPixmap(self.pixmap1)
			self.resize(self.pixmap1.width(), self.pixmap1.height())
			self.ui.verticalLayout.addWidget(self.label1)
			self.show()

		else:
			self.imageQuestion = False



		
		# add bit with getting information from mathematica then setting all the required fields

	def deleteOldQuestion(self):

		qBox = self.ui.verticalLayout_5.itemAt(1)
		self.ui.verticalLayout_5.removeItem(qBox)


		self.ui.verticalLayout.removeWidget(self.canvasA)
		self.canvasA.deleteLater()
		self.canvasA = None

		if self.imageQuestion == True:

			self.ui.verticalLayout.removeWidget(self.label1)
			self.label1.deleteLater()
			self.label1 = None


		self.newQuestion()
コード例 #55
0
 def change_cursor(self, path):
     cursor_pixmap = QPixmap(path).scaled(32, 32)
     self.setCursor(QCursor(cursor_pixmap, 0, cursor_pixmap.height()))
コード例 #56
0
ファイル: pixmapdial.py プロジェクト: falkTX/Carla
class PixmapDial(QDial):
    # enum CustomPaintMode
    CUSTOM_PAINT_MODE_NULL        = 0 # default (NOTE: only this mode has label gradient)
    CUSTOM_PAINT_MODE_CARLA_WET   = 1 # color blue-green gradient (reserved #3)
    CUSTOM_PAINT_MODE_CARLA_VOL   = 2 # color blue (reserved #3)
    CUSTOM_PAINT_MODE_CARLA_L     = 3 # color yellow (reserved #4)
    CUSTOM_PAINT_MODE_CARLA_R     = 4 # color yellow (reserved #4)
    CUSTOM_PAINT_MODE_CARLA_PAN   = 5 # color yellow (reserved #3)
    CUSTOM_PAINT_MODE_COLOR       = 6 # color, selectable (reserved #3)
    CUSTOM_PAINT_MODE_ZITA        = 7 # custom zita knob (reserved #6)
    CUSTOM_PAINT_MODE_NO_GRADIENT = 8 # skip label gradient

    # enum Orientation
    HORIZONTAL = 0
    VERTICAL   = 1

    HOVER_MIN = 0
    HOVER_MAX = 9

    MODE_DEFAULT = 0
    MODE_LINEAR = 1

    # signals
    realValueChanged = pyqtSignal(float)

    def __init__(self, parent, index=0):
        QDial.__init__(self, parent)

        self.fDialMode = self.MODE_LINEAR

        self.fMinimum   = 0.0
        self.fMaximum   = 1.0
        self.fRealValue = 0.0
        self.fPrecision = 10000
        self.fIsInteger = False

        self.fIsHovered = False
        self.fIsPressed = False
        self.fHoverStep = self.HOVER_MIN

        self.fLastDragPos = None
        self.fLastDragValue = 0.0

        self.fIndex     = index
        self.fPixmap    = QPixmap(":/bitmaps/dial_01d.png")
        self.fPixmapNum = "01"

        if self.fPixmap.width() > self.fPixmap.height():
            self.fPixmapOrientation = self.HORIZONTAL
        else:
            self.fPixmapOrientation = self.VERTICAL

        self.fLabel     = ""
        self.fLabelPos  = QPointF(0.0, 0.0)
        self.fLabelFont = QFont(self.font())
        self.fLabelFont.setPixelSize(8)
        self.fLabelWidth  = 0
        self.fLabelHeight = 0

        if self.palette().window().color().lightness() > 100:
            # Light background
            c = self.palette().dark().color()
            self.fLabelGradientColor1 = c
            self.fLabelGradientColor2 = QColor(c.red(), c.green(), c.blue(), 0)
            self.fLabelGradientColorT = [self.palette().buttonText().color(), self.palette().mid().color()]
        else:
            # Dark background
            self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
            self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
            self.fLabelGradientColorT = [Qt.white, Qt.darkGray]

        self.fLabelGradient = QLinearGradient(0, 0, 0, 1)
        self.fLabelGradient.setColorAt(0.0, self.fLabelGradientColor1)
        self.fLabelGradient.setColorAt(0.6, self.fLabelGradientColor1)
        self.fLabelGradient.setColorAt(1.0, self.fLabelGradientColor2)

        self.fLabelGradientRect = QRectF(0.0, 0.0, 0.0, 0.0)

        self.fCustomPaintMode  = self.CUSTOM_PAINT_MODE_NULL
        self.fCustomPaintColor = QColor(0xff, 0xff, 0xff)

        self.updateSizes()

        # Fake internal value, custom precision
        QDial.setMinimum(self, 0)
        QDial.setMaximum(self, self.fPrecision)
        QDial.setValue(self, 0)

        self.valueChanged.connect(self.slot_valueChanged)

    def getIndex(self):
        return self.fIndex

    def getBaseSize(self):
        return self.fPixmapBaseSize

    def forceWhiteLabelGradientText(self):
        self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
        self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
        self.fLabelGradientColorT = [Qt.white, Qt.darkGray]

    def setLabelColor(self, enabled, disabled):
        self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
        self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
        self.fLabelGradientColorT = [enabled, disabled]

    def updateSizes(self):
        self.fPixmapWidth  = self.fPixmap.width()
        self.fPixmapHeight = self.fPixmap.height()

        if self.fPixmapWidth < 1:
            self.fPixmapWidth = 1

        if self.fPixmapHeight < 1:
            self.fPixmapHeight = 1

        if self.fPixmapOrientation == self.HORIZONTAL:
            self.fPixmapBaseSize    = self.fPixmapHeight
            self.fPixmapLayersCount = self.fPixmapWidth / self.fPixmapHeight
        else:
            self.fPixmapBaseSize    = self.fPixmapWidth
            self.fPixmapLayersCount = self.fPixmapHeight / self.fPixmapWidth

        self.setMinimumSize(self.fPixmapBaseSize, self.fPixmapBaseSize + self.fLabelHeight + 5)
        self.setMaximumSize(self.fPixmapBaseSize, self.fPixmapBaseSize + self.fLabelHeight + 5)

        if not self.fLabel:
            self.fLabelHeight = 0
            self.fLabelWidth  = 0
            return

        self.fLabelWidth  = QFontMetrics(self.fLabelFont).width(self.fLabel)
        self.fLabelHeight = QFontMetrics(self.fLabelFont).height()

        self.fLabelPos.setX(float(self.fPixmapBaseSize)/2.0 - float(self.fLabelWidth)/2.0)

        if self.fPixmapNum in ("01", "02", "07", "08", "09", "10"):
            self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight)
        elif self.fPixmapNum in ("11",):
            self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight*2/3)
        else:
            self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight/2)

        self.fLabelGradient.setStart(0, float(self.fPixmapBaseSize)/2.0)
        self.fLabelGradient.setFinalStop(0, self.fPixmapBaseSize + self.fLabelHeight + 5)

        self.fLabelGradientRect = QRectF(float(self.fPixmapBaseSize)/8.0, float(self.fPixmapBaseSize)/2.0, float(self.fPixmapBaseSize*3)/4.0, self.fPixmapBaseSize+self.fLabelHeight+5)

    def setCustomPaintMode(self, paintMode):
        if self.fCustomPaintMode == paintMode:
            return

        self.fCustomPaintMode = paintMode
        self.update()

    def setCustomPaintColor(self, color):
        if self.fCustomPaintColor == color:
            return

        self.fCustomPaintColor = color
        self.update()

    def setLabel(self, label):
        if self.fLabel == label:
            return

        self.fLabel = label
        self.updateSizes()
        self.update()

    def setIndex(self, index):
        self.fIndex = index

    def setPixmap(self, pixmapId):
        self.fPixmapNum = "%02i" % pixmapId
        self.fPixmap.load(":/bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if self.isEnabled() else "d"))

        if self.fPixmap.width() > self.fPixmap.height():
            self.fPixmapOrientation = self.HORIZONTAL
        else:
            self.fPixmapOrientation = self.VERTICAL

        # special pixmaps
        if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
            # reserved for carla-wet, carla-vol, carla-pan and color
            if self.fPixmapNum == "03":
                self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_COLOR

            # reserved for carla-L and carla-R
            elif self.fPixmapNum == "04":
                self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_CARLA_L

            # reserved for zita
            elif self.fPixmapNum == "06":
                self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_ZITA

        self.updateSizes()
        self.update()

    def setPrecision(self, value, isInteger):
        self.fPrecision = value
        self.fIsInteger = isInteger
        QDial.setMaximum(self, value)

    def setMinimum(self, value):
        self.fMinimum = value

    def setMaximum(self, value):
        self.fMaximum = value

    def setValue(self, value, emitSignal=False):
        if self.fRealValue == value:
            return

        if value <= self.fMinimum:
            qtValue = 0
            self.fRealValue = self.fMinimum

        elif value >= self.fMaximum:
            qtValue = self.fPrecision
            self.fRealValue = self.fMaximum

        else:
            qtValue = round(float(value - self.fMinimum) / float(self.fMaximum - self.fMinimum) * self.fPrecision)
            self.fRealValue = value

        # Block change signal, we'll handle it ourselves
        self.blockSignals(True)
        QDial.setValue(self, qtValue)
        self.blockSignals(False)

        if emitSignal:
            self.realValueChanged.emit(self.fRealValue)

    @pyqtSlot(int)
    def slot_valueChanged(self, value):
        self.fRealValue = float(value)/self.fPrecision * (self.fMaximum - self.fMinimum) + self.fMinimum
        self.realValueChanged.emit(self.fRealValue)

    @pyqtSlot()
    def slot_updatePixmap(self):
        self.setPixmap(int(self.fPixmapNum))

    def minimumSizeHint(self):
        return QSize(self.fPixmapBaseSize, self.fPixmapBaseSize)

    def sizeHint(self):
        return QSize(self.fPixmapBaseSize, self.fPixmapBaseSize)

    def changeEvent(self, event):
        QDial.changeEvent(self, event)

        # Force pixmap update if enabled state changes
        if event.type() == QEvent.EnabledChange:
            self.setPixmap(int(self.fPixmapNum))

    def enterEvent(self, event):
        self.fIsHovered = True
        if self.fHoverStep == self.HOVER_MIN:
            self.fHoverStep = self.HOVER_MIN + 1
        QDial.enterEvent(self, event)

    def leaveEvent(self, event):
        self.fIsHovered = False
        if self.fHoverStep == self.HOVER_MAX:
            self.fHoverStep = self.HOVER_MAX - 1
        QDial.leaveEvent(self, event)

    def mousePressEvent(self, event):
        if self.fDialMode == self.MODE_DEFAULT:
            return QDial.mousePressEvent(self, event)

        if event.button() == Qt.LeftButton:
            self.fIsPressed = True
            self.fLastDragPos = event.pos()
            self.fLastDragValue = self.fRealValue

    def mouseMoveEvent(self, event):
        if self.fDialMode == self.MODE_DEFAULT:
            return QDial.mouseMoveEvent(self, event)

        if not self.fIsPressed:
            return

        range = (self.fMaximum - self.fMinimum) / 4.0
        pos   = event.pos()
        dx    = range * float(pos.x() - self.fLastDragPos.x()) / self.width()
        dy    = range * float(pos.y() - self.fLastDragPos.y()) / self.height()
        value = self.fLastDragValue + dx - dy

        if value < self.fMinimum:
            value = self.fMinimum
        elif value > self.fMaximum:
            value = self.fMaximum
        elif self.fIsInteger:
            value = float(round(value))

        self.setValue(value, True)

    def mouseReleaseEvent(self, event):
        if self.fDialMode == self.MODE_DEFAULT:
            return QDial.mouseReleaseEvent(self, event)

        if self.fIsPressed:
            self.fIsPressed = False

    def paintEvent(self, event):
        painter = QPainter(self)
        event.accept()

        painter.save()
        painter.setRenderHint(QPainter.Antialiasing, True)

        if self.fLabel:
            if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
                painter.setPen(self.fLabelGradientColor2)
                painter.setBrush(self.fLabelGradient)
                painter.drawRect(self.fLabelGradientRect)

            painter.setFont(self.fLabelFont)
            painter.setPen(self.fLabelGradientColorT[0 if self.isEnabled() else 1])
            painter.drawText(self.fLabelPos, self.fLabel)

        if self.isEnabled():
            normValue = float(self.fRealValue - self.fMinimum) / float(self.fMaximum - self.fMinimum)
            target    = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)

            curLayer = int((self.fPixmapLayersCount - 1) * normValue)

            if self.fPixmapOrientation == self.HORIZONTAL:
                xpos = self.fPixmapBaseSize * curLayer
                ypos = 0.0
            else:
                xpos = 0.0
                ypos = self.fPixmapBaseSize * curLayer

            source = QRectF(xpos, ypos, self.fPixmapBaseSize, self.fPixmapBaseSize)
            painter.drawPixmap(target, self.fPixmap, source)

            # Custom knobs (Dry/Wet and Volume)
            if self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_WET, self.CUSTOM_PAINT_MODE_CARLA_VOL):
                # knob color
                colorGreen = QColor(0x5D, 0xE7, 0x3D).lighter(100 + self.fHoverStep*6)
                colorBlue  = QColor(0x3E, 0xB8, 0xBE).lighter(100 + self.fHoverStep*6)

                # draw small circle
                ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
                ballPath = QPainterPath()
                ballPath.addEllipse(ballRect)
                #painter.drawRect(ballRect)
                tmpValue  = (0.375 + 0.75*normValue)
                ballValue = tmpValue - floor(tmpValue)
                ballPoint = ballPath.pointAtPercent(ballValue)

                # draw arc
                startAngle = 216*16
                spanAngle  = -252*16*normValue

                if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_WET:
                    painter.setBrush(colorBlue)
                    painter.setPen(QPen(colorBlue, 0))
                    painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))

                    gradient = QConicalGradient(15.5, 15.5, -45)
                    gradient.setColorAt(0.0,   colorBlue)
                    gradient.setColorAt(0.125, colorBlue)
                    gradient.setColorAt(0.625, colorGreen)
                    gradient.setColorAt(0.75,  colorGreen)
                    gradient.setColorAt(0.76,  colorGreen)
                    gradient.setColorAt(1.0,   colorGreen)
                    painter.setBrush(gradient)
                    painter.setPen(QPen(gradient, 3))

                else:
                    painter.setBrush(colorBlue)
                    painter.setPen(QPen(colorBlue, 0))
                    painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))

                    painter.setBrush(colorBlue)
                    painter.setPen(QPen(colorBlue, 3))

                painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)

            # Custom knobs (L and R)
            elif self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_L, self.CUSTOM_PAINT_MODE_CARLA_R):
                # knob color
                color = QColor(0xAD, 0xD5, 0x48).lighter(100 + self.fHoverStep*6)

                # draw small circle
                ballRect = QRectF(7.0, 8.0, 11.0, 12.0)
                ballPath = QPainterPath()
                ballPath.addEllipse(ballRect)
                #painter.drawRect(ballRect)
                tmpValue  = (0.375 + 0.75*normValue)
                ballValue = tmpValue - floor(tmpValue)
                ballPoint = ballPath.pointAtPercent(ballValue)

                painter.setBrush(color)
                painter.setPen(QPen(color, 0))
                painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.0, 2.0))

                # draw arc
                if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_L:
                    startAngle = 216*16
                    spanAngle  = -252.0*16*normValue
                else:
                    startAngle = 324.0*16
                    spanAngle  = 252.0*16*(1.0-normValue)

                painter.setPen(QPen(color, 2))
                painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)

            # Custom knobs (Color)
            elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_COLOR:
                # knob color
                color = self.fCustomPaintColor.lighter(100 + self.fHoverStep*6)

                # draw small circle
                ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
                ballPath = QPainterPath()
                ballPath.addEllipse(ballRect)
                tmpValue  = (0.375 + 0.75*normValue)
                ballValue = tmpValue - floor(tmpValue)
                ballPoint = ballPath.pointAtPercent(ballValue)

                # draw arc
                startAngle = 216*16
                spanAngle  = -252*16*normValue

                painter.setBrush(color)
                painter.setPen(QPen(color, 0))
                painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))

                painter.setBrush(color)
                painter.setPen(QPen(color, 3))
                painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)

            # Custom knobs (Zita)
            elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_ZITA:
                a = normValue * pi * 1.5 - 2.35
                r = 10.0
                x = 10.5
                y = 10.5
                x += r * sin(a)
                y -= r * cos(a)
                painter.setBrush(Qt.black)
                painter.setPen(QPen(Qt.black, 2))
                painter.drawLine(QPointF(11.0, 11.0), QPointF(x, y))

            # Custom knobs
            else:
                painter.restore()
                return

            if self.HOVER_MIN < self.fHoverStep < self.HOVER_MAX:
                self.fHoverStep += 1 if self.fIsHovered else -1
                QTimer.singleShot(20, self.update)

        else: # isEnabled()
            target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)
            painter.drawPixmap(target, self.fPixmap, target)

        painter.restore()

    def resizeEvent(self, event):
        QDial.resizeEvent(self, event)
        self.updateSizes()
コード例 #57
0
ファイル: product.py プロジェクト: ahmedshaaban97/MRI-tasks
 def adding_image_to_lbl(self , aarray):
     mostafa = qimage2ndarray.array2qimage(aarray)
     mostafa.save("output.jpg")
     pixmap = QPixmap("output.jpg")  
     pixmap = pixmap.scaled(int(pixmap.height()), int(pixmap.width()), QtCore.Qt.KeepAspectRatio)
     return pixmap
コード例 #58
0
ファイル: SnapWidget.py プロジェクト: pycom/EricShort
class SnapWidget(QWidget, Ui_SnapWidget):
    """
    Class implementing the snapshot widget.
    """
    ModeFullscreen = 0
    ModeScreen = 1
    ModeRectangle = 2
    ModeFreehand = 3
    ModeEllipse = 4
    
    def __init__(self, parent=None):
        """
        Constructor
        
        @param parent reference to the parent widget (QWidget)
        """
        super(SnapWidget, self).__init__(parent)
        self.setupUi(self)
        
        self.saveButton.setIcon(UI.PixmapCache.getIcon("fileSaveAs.png"))
        self.takeButton.setIcon(UI.PixmapCache.getIcon("cameraPhoto.png"))
        self.copyButton.setIcon(UI.PixmapCache.getIcon("editCopy.png"))
        self.copyPreviewButton.setIcon(UI.PixmapCache.getIcon("editCopy.png"))
        self.setWindowIcon(UI.PixmapCache.getIcon("ericSnap.png"))
        
        self.modeCombo.addItem(self.tr("Fullscreen"),
                               SnapWidget.ModeFullscreen)
        self.modeCombo.addItem(self.tr("Rectangular Selection"),
                               SnapWidget.ModeRectangle)
        self.modeCombo.addItem(self.tr("Ellipical Selection"),
                               SnapWidget.ModeEllipse)
        self.modeCombo.addItem(self.tr("Freehand Selection"),
                               SnapWidget.ModeFreehand)
        if QApplication.desktop().screenCount() > 1:
            self.modeCombo.addItem(self.tr("Current Screen"),
                                   SnapWidget.ModeScreen)
        self.__mode = int(Preferences.Prefs.settings.value("Snapshot/Mode", 0))
        index = self.modeCombo.findData(self.__mode)
        if index == -1:
            index = 0
        self.modeCombo.setCurrentIndex(index)
        
        self.__delay = int(
            Preferences.Prefs.settings.value("Snapshot/Delay", 0))
        self.delaySpin.setValue(self.__delay)
        
        if PYQT_VERSION_STR >= "5.0.0":
            from PyQt5.QtCore import QStandardPaths
            picturesLocation = QStandardPaths.writableLocation(
                QStandardPaths.PicturesLocation)
        else:
            from PyQt5.QtGui import QDesktopServices
            picturesLocation = QDesktopServices.storageLocation(
                QDesktopServices.PicturesLocation)
        self.__filename = Preferences.Prefs.settings.value(
            "Snapshot/Filename",
            os.path.join(picturesLocation,
                         self.tr("snapshot") + "1.png"))
        
        self.__grabber = None
        self.__snapshot = QPixmap()
        self.__savedPosition = QPoint()
        self.__modified = False
        self.__locale = QLocale()
        
        self.__grabberWidget = QWidget(None, Qt.X11BypassWindowManagerHint)
        self.__grabberWidget.move(-10000, -10000)
        self.__grabberWidget.installEventFilter(self)
        
        self.__initFileFilters()
        
        self.__initShortcuts()
        
        self.preview.startDrag.connect(self.__dragSnapshot)
        
        from .SnapshotTimer import SnapshotTimer
        self.__grabTimer = SnapshotTimer()
        self.__grabTimer.timeout.connect(self.__grabTimerTimeout)
        self.__updateTimer = QTimer()
        self.__updateTimer.setSingleShot(True)
        self.__updateTimer.timeout.connect(self.__updatePreview)
        
        self.__updateCaption()
        self.takeButton.setFocus()
    
    def __initFileFilters(self):
        """
        Private method to define the supported image file filters.
        """
        filters = {
            'bmp': self.tr("Windows Bitmap File (*.bmp)"),
            'gif': self.tr("Graphic Interchange Format File (*.gif)"),
            'ico': self.tr("Windows Icon File (*.ico)"),
            'jpg': self.tr("JPEG File (*.jpg)"),
            'mng': self.tr("Multiple-Image Network Graphics File (*.mng)"),
            'pbm': self.tr("Portable Bitmap File (*.pbm)"),
            'pcx': self.tr("Paintbrush Bitmap File (*.pcx)"),
            'pgm': self.tr("Portable Graymap File (*.pgm)"),
            'png': self.tr("Portable Network Graphics File (*.png)"),
            'ppm': self.tr("Portable Pixmap File (*.ppm)"),
            'sgi': self.tr("Silicon Graphics Image File (*.sgi)"),
            'svg': self.tr("Scalable Vector Graphics File (*.svg)"),
            'tga': self.tr("Targa Graphic File (*.tga)"),
            'tif': self.tr("TIFF File (*.tif)"),
            'xbm': self.tr("X11 Bitmap File (*.xbm)"),
            'xpm': self.tr("X11 Pixmap File (*.xpm)"),
        }
        
        outputFormats = []
        writeFormats = QImageWriter.supportedImageFormats()
        for writeFormat in writeFormats:
            try:
                outputFormats.append(filters[bytes(writeFormat).decode()])
            except KeyError:
                pass
        outputFormats.sort()
        self.__outputFilter = ';;'.join(outputFormats)
        
        self.__defaultFilter = filters['png']
    
    def __initShortcuts(self):
        """
        Private method to initialize the keyboard shortcuts.
        """
        self.__quitShortcut = QShortcut(
            QKeySequence(QKeySequence.Quit), self, self.close)
        
        self.__copyShortcut = QShortcut(
            QKeySequence(QKeySequence.Copy), self,
            self.copyButton.animateClick)
        
        self.__quickSaveShortcut = QShortcut(
            QKeySequence(Qt.Key_Q), self, self.__quickSave)
        
        self.__save1Shortcut = QShortcut(
            QKeySequence(QKeySequence.Save), self,
            self.saveButton.animateClick)
        self.__save2Shortcut = QShortcut(
            QKeySequence(Qt.Key_S), self, self.saveButton.animateClick)
        
        self.__grab1Shortcut = QShortcut(
            QKeySequence(QKeySequence.New), self, self.takeButton.animateClick)
        self.__grab2Shortcut = QShortcut(
            QKeySequence(Qt.Key_N), self, self.takeButton.animateClick)
        self.__grab3Shortcut = QShortcut(
            QKeySequence(Qt.Key_Space), self, self.takeButton.animateClick)
    
    def __quickSave(self):
        """
        Private slot to save the snapshot bypassing the file selection dialog.
        """
        if not self.__snapshot.isNull():
            while os.path.exists(self.__filename):
                self.__autoIncFilename()
            
            if self.__saveImage(self.__filename):
                self.__modified = False
                self.__autoIncFilename()
                self.__updateCaption()
    
    @pyqtSlot()
    def on_saveButton_clicked(self):
        """
        Private slot to save the snapshot.
        """
        if not self.__snapshot.isNull():
            while os.path.exists(self.__filename):
                self.__autoIncFilename()
            
            fileName, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
                self,
                self.tr("Save Snapshot"),
                self.__filename,
                self.__outputFilter,
                self.__defaultFilter,
                E5FileDialog.Options(E5FileDialog.DontConfirmOverwrite))
            if not fileName:
                return
            
            ext = QFileInfo(fileName).suffix()
            if not ext:
                ex = selectedFilter.split("(*")[1].split(")")[0]
                if ex:
                    fileName += ex
            
            if self.__saveImage(fileName):
                self.__modified = False
                self.__filename = fileName
                self.__autoIncFilename()
                self.__updateCaption()
    
    def __saveImage(self, fileName):
        """
        Private method to save the snapshot.
        
        @param fileName name of the file to save to (string)
        @return flag indicating success (boolean)
        """
        if QFileInfo(fileName).exists():
            res = E5MessageBox.yesNo(
                self,
                self.tr("Save Snapshot"),
                self.tr("<p>The file <b>{0}</b> already exists."
                        " Overwrite it?</p>").format(fileName),
                icon=E5MessageBox.Warning)
            if not res:
                return False
        
        file = QFile(fileName)
        if not file.open(QFile.WriteOnly):
            E5MessageBox.warning(
                self, self.tr("Save Snapshot"),
                self.tr("Cannot write file '{0}:\n{1}.")
                .format(fileName, file.errorString()))
            return False
        
        ok = self.__snapshot.save(file)
        file.close()
        
        if not ok:
            E5MessageBox.warning(
                self, self.tr("Save Snapshot"),
                self.tr("Cannot write file '{0}:\n{1}.")
                .format(fileName, file.errorString()))
        
        return ok
    
    def __autoIncFilename(self):
        """
        Private method to auto-increment the file name.
        """
        # Extract the file name
        name = os.path.basename(self.__filename)
        
        # If the name contains a number, then increment it.
        numSearch = QRegExp("(^|[^\\d])(\\d+)")
        # We want to match as far left as possible, and when the number is
        # at the start of the name.
        
        # Does it have a number?
        start = numSearch.lastIndexIn(name)
        if start != -1:
            # It has a number, increment it.
            start = numSearch.pos(2)    # Only the second group is of interest.
            numAsStr = numSearch.capturedTexts()[2]
            number = "{0:0{width}d}".format(
                int(numAsStr) + 1, width=len(numAsStr))
            name = name[:start] + number + name[start + len(numAsStr):]
        else:
            # no number
            start = name.rfind('.')
            if start != -1:
                # has a '.' somewhere, e.g. it has an extension
                name = name[:start] + '1' + name[start:]
            else:
                # no extension, just tack it on to the end
                name += '1'
        
        self.__filename = os.path.join(os.path.dirname(self.__filename), name)
        self.__updateCaption()
    
    @pyqtSlot()
    def on_takeButton_clicked(self):
        """
        Private slot to take a snapshot.
        """
        self.__mode = self.modeCombo.itemData(self.modeCombo.currentIndex())
        self.__delay = self.delaySpin.value()
        
        self.__savedPosition = self.pos()
        self.hide()
        
        if self.__delay:
            self.__grabTimer.start(self.__delay)
        else:
            QTimer.singleShot(200, self.__startUndelayedGrab)
    
    def __grabTimerTimeout(self):
        """
        Private slot to perform a delayed grab operation.
        """
        if self.__mode == SnapWidget.ModeRectangle:
            self.__grabRectangle()
        elif self.__mode == SnapWidget.ModeEllipse:
            self.__grabEllipse()
        elif self.__mode == SnapWidget.ModeFreehand:
            self.__grabFreehand()
        else:
            self.__performGrab()
    
    def __startUndelayedGrab(self):
        """
        Private slot to perform an undelayed grab operation.
        """
        if self.__mode == SnapWidget.ModeRectangle:
            self.__grabRectangle()
        elif self.__mode == SnapWidget.ModeEllipse:
            self.__grabEllipse()
        elif self.__mode == SnapWidget.ModeFreehand:
            self.__grabFreehand()
        else:
            if Globals.isMacPlatform():
                self.__performGrab()
            else:
                self.__grabberWidget.show()
                self.__grabberWidget.grabMouse(Qt.CrossCursor)
    
    def __grabRectangle(self):
        """
        Private method to grab a rectangular screen region.
        """
        from .SnapshotRegionGrabber import SnapshotRegionGrabber
        self.__grabber = SnapshotRegionGrabber(
            mode=SnapshotRegionGrabber.Rectangle)
        self.__grabber.grabbed.connect(self.__captured)
    
    def __grabEllipse(self):
        """
        Private method to grab an elliptical screen region.
        """
        from .SnapshotRegionGrabber import SnapshotRegionGrabber
        self.__grabber = SnapshotRegionGrabber(
            mode=SnapshotRegionGrabber.Ellipse)
        self.__grabber.grabbed.connect(self.__captured)
    
    def __grabFreehand(self):
        """
        Private method to grab a non-rectangular screen region.
        """
        from .SnapshotFreehandGrabber import SnapshotFreehandGrabber
        self.__grabber = SnapshotFreehandGrabber()
        self.__grabber.grabbed.connect(self.__captured)
    
    def __performGrab(self):
        """
        Private method to perform a screen grab other than a selected region.
        """
        self.__grabberWidget.releaseMouse()
        self.__grabberWidget.hide()
        self.__grabTimer.stop()
        
        if self.__mode == SnapWidget.ModeFullscreen:
            desktop = QApplication.desktop()
            if qVersion() >= "5.0.0":
                self.__snapshot = QApplication.screens()[0].grabWindow(
                    desktop.winId(), desktop.x(), desktop.y(),
                    desktop.width(), desktop.height())
            else:
                self.__snapshot = QPixmap.grabWindow(
                    desktop.winId(), desktop.x(), desktop.y(),
                    desktop.width(), desktop.height())
        elif self.__mode == SnapWidget.ModeScreen:
            desktop = QApplication.desktop()
            screenId = desktop.screenNumber(QCursor.pos())
            geom = desktop.screenGeometry(screenId)
            x = geom.x()
            y = geom.y()
            if qVersion() >= "5.0.0":
                self.__snapshot = QApplication.screens()[0].grabWindow(
                    desktop.winId(), x, y, geom.width(), geom.height())
            else:
                self.__snapshot = QPixmap.grabWindow(
                    desktop.winId(), x, y, geom.width(), geom.height())
        else:
            self.__snapshot = QPixmap()
        
        self.__redisplay()
        self.__modified = True
        self.__updateCaption()
    
    def __redisplay(self):
        """
        Private method to redisplay the window.
        """
        self.__updatePreview()
        QApplication.restoreOverrideCursor()
        if not self.__savedPosition.isNull():
            self.move(self.__savedPosition)
        self.show()
        self.raise_()
        
        self.saveButton.setEnabled(not self.__snapshot.isNull())
        self.copyButton.setEnabled(not self.__snapshot.isNull())
        self.copyPreviewButton.setEnabled(not self.__snapshot.isNull())
    
    @pyqtSlot()
    def on_copyButton_clicked(self):
        """
        Private slot to copy the snapshot to the clipboard.
        """
        if not self.__snapshot.isNull():
            QApplication.clipboard().setPixmap(QPixmap(self.__snapshot))
    
    @pyqtSlot()
    def on_copyPreviewButton_clicked(self):
        """
        Private slot to copy the snapshot preview to the clipboard.
        """
        QApplication.clipboard().setPixmap(self.preview.pixmap())
    
    def __captured(self, pixmap):
        """
        Private slot to show a preview of the snapshot.
        
        @param pixmap pixmap of the snapshot (QPixmap)
        """
        self.__grabber.close()
        self.__snapshot = QPixmap(pixmap)
        
        self.__grabber.grabbed.disconnect(self.__captured)
        self.__grabber = None
        
        self.__redisplay()
        self.__modified = True
        self.__updateCaption()
    
    def __updatePreview(self):
        """
        Private slot to update the preview picture.
        """
        self.preview.setToolTip(self.tr(
            "Preview of the snapshot image ({0} x {1})").format(
            self.__locale.toString(self.__snapshot.width()),
            self.__locale.toString(self.__snapshot.height()))
        )
        self.preview.setPreview(self.__snapshot)
        self.preview.adjustSize()
    
    def resizeEvent(self, evt):
        """
        Protected method handling a resizing of the window.
        
        @param evt resize event (QResizeEvent)
        """
        self.__updateTimer.start(200)
    
    def __dragSnapshot(self):
        """
        Private slot handling the dragging of the preview picture.
        """
        drag = QDrag(self)
        mimeData = QMimeData()
        mimeData.setImageData(self.__snapshot)
        drag.setMimeData(mimeData)
        drag.setPixmap(self.preview.pixmap())
        drag.exec_(Qt.CopyAction)
    
    def eventFilter(self, obj, evt):
        """
        Public method to handle event for other objects.
        
        @param obj reference to the object (QObject)
        @param evt reference to the event (QEvent)
        @return flag indicating that the event should be filtered out (boolean)
        """
        if obj == self.__grabberWidget and \
                evt.type() == QEvent.MouseButtonPress:
            if QWidget.mouseGrabber() != self.__grabberWidget:
                return False
            if evt.button() == Qt.LeftButton:
                self.__performGrab()
        
        return False
    
    def closeEvent(self, evt):
        """
        Protected method handling the close event.
        
        @param evt close event (QCloseEvent)
        """
        if self.__modified:
            res = E5MessageBox.question(
                self,
                self.tr("eric6 Snapshot"),
                self.tr(
                    """The application contains an unsaved snapshot."""),
                E5MessageBox.StandardButtons(
                    E5MessageBox.Abort |
                    E5MessageBox.Discard |
                    E5MessageBox.Save))
            if res == E5MessageBox.Abort:
                evt.ignore()
                return
            elif res == E5MessageBox.Save:
                self.on_saveButton_clicked()
        
        Preferences.Prefs.settings.setValue(
            "Snapshot/Delay", self.delaySpin.value())
        Preferences.Prefs.settings.setValue(
            "Snapshot/Mode",
            self.modeCombo.itemData(self.modeCombo.currentIndex()))
        Preferences.Prefs.settings.setValue(
            "Snapshot/Filename", self.__filename)
        Preferences.Prefs.settings.sync()
    
    def __updateCaption(self):
        """
        Private method to update the window caption.
        """
        self.setWindowTitle("{0}[*] - {1}".format(
            os.path.basename(self.__filename),
            self.tr("eric6 Snapshot")))
        self.setWindowModified(self.__modified)
        self.pathNameEdit.setText(os.path.dirname(self.__filename))
コード例 #59
0
class QtVideoMockup(AbstractVideoDevice):

    def __init__(self, name):
        AbstractVideoDevice.__init__(self, name)
        self.force_update = None
        self.image_type = None
        self.image = None

    def init(self):
        current_path = os.path.dirname(os.path.abspath(__file__)).split(os.sep)
        current_path = os.path.join(*current_path[1:-2])

        default_image_path = "/" + current_path + "/test/fakeimg.jpg"
        image_path = self.getProperty("file_name", default_image_path)

        self.image = QPixmap(image_path)
        self.image_dimensions = (self.image.width(), self.image.height())
        self.painter = QPainter(self.image)

        custom_pen = QPen(Qt.SolidLine)
        custom_pen.setColor(Qt.black)
        custom_pen.setWidth(1)
        self.painter.setPen(custom_pen)

        custom_brush = QBrush(Qt.SolidPattern)
        custom_brush.setColor(Qt.lightGray)
        self.painter.setBrush(custom_brush)

        self.setIsReady(True)
        AbstractVideoDevice.init(self)

    def get_new_image(self):
        self.painter.drawRect(self.image.width() - 75, self.image.height() - 30, 70, 20)
        self.painter.drawText(
            self.image.width() - 70, self.image.height() - 15, time.strftime("%H:%M:%S")
        )
        self.emit("imageReceived", self.image)

    def save_snapshot(self, filename, image_type="PNG"):
        qimage = QImage(self.image)
        qimage.save(filename, image_type)

    def get_snapshot(self, bw=None, return_as_array=None):
        qimage = QImage(self.image)
        if return_as_array:
            qimage = qimage.convertToFormat(4)
            ptr = qimage.bits()
            ptr.setsize(qimage.byteCount())

            image_array = np.array(ptr).reshape(qimage.height(), qimage.width(), 4)
            if bw:
                return np.dot(image_array[..., :3], [0.299, 0.587, 0.144])
            else:
                return image_array
        else:
            if bw:
                return qimage.convertToFormat(QImage.Format_Mono)
            else:
                return qimage

    def get_contrast(self):
        return 34

    def set_contrast(self, contrast_value):
        return

    def get_brightness(self):
        return 54

    def set_brightness(self, brightness_value):
        return

    def get_gain(self):
        return 32

    def set_gain(self, gain_value):
        return

    def get_gamma(self):
        return 22

    def set_gamma(self, gamma_value):
        return

    def get_exposure_time(self):
        return 0.23

    def get_video_live(self):
        return True

    def get_raw_image_size(self):
        return list(self.image_dimensions)
コード例 #60
0
class MyWidget(QWidget):
    def __init__(self, parent):
        super().__init__(parent)
        self.initUI()

    def initUI(self):
        self.setMinimumSize(1, 30)
        self.setFocusPolicy(Qt.StrongFocus) # to be able to accept key events

        self.paint_image = QPixmap(self.width(), self.height())
        self.background_color = QColor(70, 70, 70)

        self.fps = 30
        self.timer = QTimer()
        self.timer.timeout.connect(self.nextFrame)
        self.timer.start(1000 / 30)

        self.frame_count = 0
        self.x1 = 50
        self.y1 = 50
        self.radius1 = 50

        self.color2 = QColor(0, 0, 255)
        self.x2 = 50
        self.y2 = 50
        self.angle2 = 20


    def setFrameRate(self, fps):
        self.fps = fps
        if self.fps > 0:
            if not self.timer.isActive():
                self.timer.start()
            self.timer.setInterval(1000 / self.fps)
        else:
            self.timer.stop()

    def nextFrame(self):
        mouse_pos = self.mapFromGlobal(QCursor.pos())
        mouse_x = mouse_pos.x()
        mouse_y = mouse_pos.y()

        self.x1 = mouse_x
        self.y1 = mouse_y
        self.radius1 = self.radius1 + math.sin(self.frame_count / 8) * 4

        delay = 20
        self.x2 += (mouse_x - self.x2) / delay
        self.y2 += (mouse_y - self.y2) / delay

        self.frame_count += 1

        if self.paint_image.width() != self.width() or self.paint_image.height() != self.height():
            self.paint_image = QPixmap(self.width(), self.height())
            self.paint_image.fill(self.background_color)

        p = QPainter()
        p.begin(self.paint_image) # auf das paint_image malen
        p.setBackground(self.background_color) # color when stuff is erased

        # Hintergrund löschen, wenn Rechteck bei der Maus angekommen ist
        # print("{0}, {1}".format(self.x2, mouse_x))
        if round(self.x2) == mouse_x and round(self.y2) == mouse_y:
            p.eraseRect(0, 0, self.paint_image.width(), self.paint_image.height())

        self.drawFrame(p)
        p.end()
        self.repaint()

    def drawFrame(self, p):
        pen = QPen(QColor(20, 20, 20), 10, Qt.SolidLine)
        p.setPen(pen)

        x1 = self.x1 - self.radius1 / 2
        y1 = self.y1 - self.radius1 / 2
        p.drawEllipse(x1, y1, self.radius1, self.radius1)

        pen = QPen(self.color2, 5, Qt.SolidLine) # blau
        p.setPen(pen)
        w2 = 50

        # see https://www.khanacademy.org/computing/computer-programming/programming-games-visualizations/programming-transformations/a/rotation
        p.save()
        p.translate(self.x2, self.y2)
        p.rotate(self.angle2) # todo keypress
        p.drawRect(0, 0, w2, w2)
        p.restore()

    def paintEvent(self, e):

        p = QPainter()
        p.begin(self)

        # self.drawFrame(p) # Frame direkt malen (ohne paint_image)

        p.drawPixmap(0, 0, self.paint_image)
        p.end()

    def keyPressEvent(self, e):
        print(e.key(), e.text())
        if e.key() == Qt.Key_Left:
            self.angle2 -= 10
        elif e.key() == Qt.Key_Right:
            self.angle2 += 10

        if e.key() == Qt.Key_P:
            print("P pressed")

        if e.key() == Qt.Key_C:
            print("C pressed")
            if self.color2 == QColor(0, 0, 255):
                self.color2 = QColor(0, 255, 0)
            else:
                self.color2 = QColor(0, 0, 255)

    def mousePressEvent(self, e):
        print(e.x(), e.y())

        p = QPainter()
        p.begin(self.paint_image) # auf das paint_image malen
        self.drawOnClick(e, p)
        p.end()
        self.repaint()

    def drawOnClick(self, e, p):
        pen = QPen(QColor(255, 0, 0), 20, Qt.SolidLine, Qt.RoundCap)
        p.setPen(pen)
        p.drawPoint(e.x(), e.y())