class frame(QtGui.QLabel):
def __init__(self, parent=None):
QtGui.QLabel.__init__(self, parent)
self.rubberBand = QRubberBand(QRubberBand.Rectangle, self)
self.origin = QPoint()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
global LTx, LTy
[LTx, LTy] = [event.pos().x(), event.pos().y()]
self.origin = QPoint(event.pos())
self.rubberBand.setGeometry(QRect(self.origin, QSize()))
self.rubberBand.show()
def mouseMoveEvent(self, event):
if not self.origin.isNull():
self.rubberBand.setGeometry(
QRect(self.origin, event.pos()).normalized())
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
global RBx, RBy
[RBx, RBy] = [event.pos().x(), event.pos().y()]
self.rubberBand.hide()
class MyLabel(QLabel):
def __init__(self, parent=None):
QLabel.__init__(self, parent)
self.rubberBand = QRubberBand(QRubberBand.Rectangle, self)
self.origin = QPoint()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.origin = QPoint(event.pos())
self.rubberBand.setGeometry(QRect(self.origin, QSize()))
self.rubberBand.show()
def mouseMoveEvent(self, event):
if not self.origin.isNull():
self.rubberBand.setGeometry(
QRect(self.origin, event.pos()).normalized())
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
self.rubberBand.hide()
class Window(QMainWindow):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.setWindowFlags(Qt.FramelessWindowHint)
self.rubberBand = QRubberBand(QRubberBand.Rectangle, self)
self.origin = QPoint()
self.repaint()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.origin = QPoint(event.pos())
self.rubberBand.setGeometry(QRect(self.origin, QSize()))
self.rubberBand.show()
def mouseMoveEvent(self, event):
if not self.origin.isNull():
self.rubberBand.setGeometry(QRect(self.origin, event.pos()).normalized())
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
self.rubberBand.hide()
class ClickReportingInterpreter(QObject):
rightClickReceived = pyqtSignal(object, QPoint) # list of indexes, global window coordinate of click
leftClickReceived = pyqtSignal(object, QPoint) # ditto
leftClickReleased = pyqtSignal(object, object)
def __init__(self, navigationInterpreter, positionModel, editor):
QObject.__init__(self)
self.baseInterpret = navigationInterpreter
self.posModel = positionModel
self.rubberBand = QRubberBand(QRubberBand.Rectangle, editor)
self.origin = QPoint()
self.originpos = object()
def start( self ):
self.baseInterpret.start()
def stop( self ):
self.baseInterpret.stop()
def eventFilter( self, watched, event ):
if event.type() == QEvent.MouseButtonPress:
pos = [int(i) for i in self.posModel.cursorPos]
pos = [self.posModel.time] + pos + [self.posModel.channel]
if event.button() == Qt.LeftButton:
self.origin = QPoint(event.pos())
self.originpos = pos
self.rubberBand.setGeometry(QRect(self.origin, QSize()))
self.rubberBand.show()
gPos = watched.mapToGlobal( event.pos() )
self.leftClickReceived.emit( pos, gPos )
if event.button() == Qt.RightButton:
gPos = watched.mapToGlobal( event.pos() )
self.rightClickReceived.emit( pos, gPos )
if event.type() == QEvent.MouseMove:
if not self.origin.isNull():
self.rubberBand.setGeometry(QRect(self.origin,
event.pos()).normalized())
if event.type() == QEvent.MouseButtonRelease:
pos = [int(i) for i in self.posModel.cursorPos]
pos = [self.posModel.time] + pos + [self.posModel.channel]
if event.button() == Qt.LeftButton:
self.rubberBand.hide()
self.leftClickReleased.emit( self.originpos,pos )
# Event is always forwarded to the navigation interpreter.
return self.baseInterpret.eventFilter(watched, event)
class Window(QLabel):
#First of all, user can watch the full screenshot
def __init__(self, parent=None):
QLabel.__init__(self, parent)
self.rubberBand = QRubberBand(QRubberBand.Rectangle, self)
self.origin = QPoint()
img = QPixmap.grabWindow(QApplication.desktop().winId())
self.setPixmap(img)
#Using Mouse, user can select area of screenshot to choose word(english) for searching.
# This version cannot support capture of area.
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.origin = QPoint(event.pos())
posDictionary1.append(self.origin.x())
posDictionary1.append(self.origin.y())
self.rubberBand.setGeometry(QRect(self.origin, QSize()))
self.rubberBand.show()
def mouseMoveEvent(self, event):
if not self.origin.isNull():
self.rubberBand.setGeometry(
QRect(self.origin, event.pos()).normalized())
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
x = (QPoint(event.pos())).x()
y = (QPoint(event.pos())).y()
posDictionary2.append(x)
posDictionary2.append(y)
self.rubberBand.hide()
self.close()
Capture(posDictionary1[0], posDictionary1[1], posDictionary2[0],
posDictionary2[1])
Result_Window()
class ScreenshotWindow(QLabel):
screenshot_close = pyqtSignal(Fotbalek)
main_handler = None
def __init__(self, parent=None):
QLabel.__init__(self, parent)
self.rubberBand = QRubberBand(QRubberBand.Rectangle, self)
self.origin = QPoint()
self.setWindowFlags(Qt.FramelessWindowHint)
self.setGeometry(100, 100, 100, 100)
self.setAutoFillBackground(True)
self.screenshot_close.connect(Fotbalek.load_pix)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.origin = QPoint(event.pos())
self.rubberBand.setGeometry(QRect(self.origin, QSize()))
self.rubberBand.show()
def mouseMoveEvent(self, event):
if not self.origin.isNull():
self.rubberBand.setGeometry(
QRect(self.origin, event.pos()).normalized())
def mouseReleaseEvent(self, event):
self.rubberBand.hide()
currentQrect = self.rubberBand.geometry()
cropPixmap = self.pixmap().copy(currentQrect)
cropPixmap.save('letters.bmp')
self.close()
def closeEvent(self, event):
self.screenshot_close.emit(self.main_handler)
class ScreenshotWindow(QLabel):
screenshot_close = pyqtSignal(Fotbalek)
main_handler = None
def __init__(self, parent = None):
QLabel.__init__(self, parent)
self.rubberBand = QRubberBand(QRubberBand.Rectangle, self)
self.origin = QPoint()
self.setWindowFlags(Qt.FramelessWindowHint)
self.setGeometry(100,100,100,100)
self.setAutoFillBackground(True)
self.screenshot_close.connect(Fotbalek.load_pix)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.origin = QPoint(event.pos())
self.rubberBand.setGeometry(QRect(self.origin, QSize()))
self.rubberBand.show()
def mouseMoveEvent(self, event):
if not self.origin.isNull():
self.rubberBand.setGeometry(QRect(self.origin, event.pos()).normalized())
def mouseReleaseEvent(self, event):
self.rubberBand.hide()
currentQrect = self.rubberBand.geometry()
cropPixmap = self.pixmap().copy(currentQrect)
cropPixmap.save('letters.bmp')
self.close()
def closeEvent(self, event):
self.screenshot_close.emit(self.main_handler)
class BoxInterpreter(QObject):
rightClickReceived = pyqtSignal(object, QPoint) # list of indexes, global window coordinate of click
leftClickReceived = pyqtSignal(object, QPoint)
leftClickReleased = pyqtSignal(object, object)
#boxAdded= pyqtSignal(object, object)
#focusObjectChages= pyqtSignal(object, QPoint)
cursorPositionChanged = pyqtSignal(object)
deleteSelectedItemsSignal= pyqtSignal() #send the signal that we want to delete the currently selected item
acceptBoxManipulation = True
def __init__(self, navigationInterpreter, positionModel, BoxContr, widget):
'''
Class which interacts directly with the image scene
:param navigationInterpreter:
:param positionModel:
:param BoxContr:
:param widget: The main widget
'''
QObject.__init__(self)
self.baseInterpret = navigationInterpreter
self._posModel = positionModel
self.rubberBand = RedRubberBand(QRubberBand.Rectangle, widget)
self.boxController=BoxContr
self.leftClickReleased.connect(BoxContr.addNewBox)
self.rightClickReceived.connect(BoxContr.onChangedPos)
#self.deleteSelectedItemsSignal.connect(BoxContr.deleteSelectedItems)
self.origin = QPoint()
self.originpos = object()
def start( self ):
self.baseInterpret.start()
def stop( self ):
self.baseInterpret.stop()
def eventFilter( self, watched, event ):
pos = [int(i) for i in self._posModel.cursorPos]
pos = [self._posModel.time] + pos + [self._posModel.channel]
#Rectangles under the current point
items=watched.scene().items(QPointF(*pos[1:3]))
items=filter(lambda el: isinstance(el, QGraphicsResizableRect),items)
#Keyboard interaction
if event.type()==QEvent.KeyPress:
#Switch selection
if event.key()==Qt.Key_Space :
#assert items[0]._hovering
#items[0].setZValue(1)
#for el in items:
# print el.zValue()
if len(items)>1:
items[-1].setZValue(items[0].zValue()+1)
items[0].setSelected(False)
items[-1].setSelected(True)
#items[0].setZero()
if event.key()==Qt.Key_Control :
QApplication.setOverrideCursor(QtCore.Qt.OpenHandCursor)
# #Delete element
# if event.key()==Qt.Key_Delete:
# self.deleteSelectedItemsSignal.emit()
if event.type()==QEvent.KeyRelease:
if event.key()==Qt.Key_Control :
QApplication.restoreOverrideCursor()
#Pressing mouse and menaging rubber band
if event.type() == QEvent.MouseButtonPress:
if event.button() == Qt.LeftButton:
self.origin = QPoint(event.pos())
self.originpos = pos
self.rubberBand.setGeometry(QRect(self.origin, QSize()))
itemsall=watched.scene().items(QPointF(*pos[1:3]))
itemsall =filter(lambda el: isinstance(el, ResizeHandle), itemsall)
# if len(itemsall)==0: #show rubber band only if there is no rubbber band
# self.rubberBand.show()
modifiers=QApplication.keyboardModifiers()
if modifiers != Qt.ControlModifier and modifiers != Qt.ShiftModifier and len(itemsall)==0: #show rubber band if Ctrl is not pressed
self.rubberBand.show()
gPos = watched.mapToGlobal( event.pos() )
self.leftClickReceived.emit( pos, gPos )
if event.button() == Qt.RightButton:
gPos = watched.mapToGlobal( event.pos() )
self.rightClickReceived.emit( pos, gPos )
if event.type() == QEvent.MouseMove:
self.cursorPositionChanged.emit(event.pos())
if not self.origin.isNull():
self.rubberBand.setGeometry(QRect(self.origin,
event.pos()).normalized())
#Relasing the button
if event.type() == QEvent.MouseButtonRelease:
pos = [int(i) for i in self._posModel.cursorPos]
pos = [self._posModel.time] + pos + [self._posModel.channel]
if self.rubberBand.isVisible():
if event.button() == Qt.LeftButton:
self.rubberBand.hide()
self.leftClickReleased.emit( self.originpos,pos )
# Event is always forwarded to the navigation interpreter.
return self.baseInterpret.eventFilter(watched, event)
class VisionneurImagePourEKD(QScrollArea):
''' Classe pour l'affichage des images (avec des barres de
défilement)'''
def __init__(self, img=None):
QScrollArea.__init__(self)
# Déclaration du drapeau: a-t-on chargé un *.gif
if img and os.path.splitext(img)[1]!=".gif":
self.gif = 1
else:
self.gif = 0
# Facteur de redimensionnement de l'image à afficher par rapport à la taille réelle de l'image
self.factor = 1
# Variables de paramètres
self.modeTransformation=Qt.SmoothTransformation
#self.modeTransformation=Qt.FastTransformation
# widget qui contiendra l'image
self.imageLabel = QLabel()
self.imageLabel.setAlignment(Qt.AlignCenter)
self.setBackgroundRole(QPalette.Dark)
self.setWidget(self.imageLabel)
# Indispensable pour ne pas avoir d'images tronquées, lors du chargement de nvll img
self.setWidgetResizable(True)
# Position du curseur dans le QScrollArea au moment du clic de la souris
self.positionPresseeSourisIni = QPoint()
# Position du point haut-gauche du QScrollArea par rapport au QPixMap entier au
# moment du clic de la souris (par la suite appelée "position de la barre de défilement")
self.positionBarrePresseeSourisIni = QPoint()
# Création du menu contextuel
self.menuZoom=QMenu("Zoom")
# Entrée zoom taille réelle
self.menuTailleReelle=self.menuZoom.addAction(_(u'&Taille Réelle'))
self.menuTailleReelle.setIcon(QIcon("Icones" + os.sep + "taillereelle.png"))
self.connect(self.menuTailleReelle, SIGNAL("triggered()"), self.setTailleReelle)
# Entrée zoom taille fenetre
self.menuTailleFenetre=self.menuZoom.addAction(_(u'&Adapter à la fenêtre'))
self.menuTailleFenetre.setIcon(QIcon("Icones" + os.sep + "fenetre.png"))
self.connect(self.menuTailleFenetre, SIGNAL("triggered()"), self.setTailleFenetre)
# Entrée zoom +
self.menuZoomPlus=self.menuZoom.addAction(_(u'&Zoom Avant'))
self.menuZoomPlus.setIcon(QIcon("Icones" + os.sep + "zoomplus.png"))
self.connect(self.menuZoomPlus, SIGNAL("triggered()"), self.zoomAvant)
# Entrée zoom -
self.menuZoomMoins=self.menuZoom.addAction(_(u'&Zoom Arrière'))
self.menuZoomMoins.setIcon(QIcon("Icones" + os.sep + "zoommoins.png"))
self.connect(self.menuZoomMoins, SIGNAL("triggered()"), self.zoomArriere)
# Entrée mettre en pause/démarrer l'animation du gif
self.menuStartPauseGif=self.menuZoom.addAction(_(u"Mettre en pause/démarrer l'animation"))
self.menuStartPauseGif.setIcon(QIcon("Icones" + os.sep + "player_end.png"))
self.connect(self.menuStartPauseGif, SIGNAL("triggered()"), self.startPauseGif)
# Entrée mettre en pause/démarrer l'animation du gif
self.menuStopGif=self.menuZoom.addAction(_(u"Arrêter l'animation"))
self.menuStopGif.setIcon(QIcon("Icones" + os.sep + "player_stop.png"))
self.connect(self.menuStopGif, SIGNAL("triggered()"), self.stopGif)
# On cache les 2 menus de *.gif si on ne traite pas ce format
if not self.gif:
self.menuStartPauseGif.setVisible(False)
self.menuStopGif.setVisible(False)
# Si une image est en paramètre de classe, on l'affiche directement
# sinon on pourra toujours l'afficher plus tard en appelant la
# méthode setImage(), le moment venu
if img:
self.setImage(img)
self.setToolTip(img)
else:
# image par défaut
self.setImage("Icones" + os.sep + "avant-image.png")
self.setToolTip(_(u"image d'accueil"))
self.setTailleReelle()
def mousePressEvent(self, event):
"Menu contextuel et enregistrement de données préparant le déplacement de l'image par pincement"
# Menu contextuel
if event.button() == Qt.RightButton:
self.menuZoom.popup(event.globalPos())
# On enregistre la position du curseur et de la barre de défilement au moment du clic
elif event.button() == Qt.LeftButton:
self.positionPresseeSourisIni = QPoint(event.pos())
self.positionBarrePresseeSourisIni.setX(self.horizontalScrollBar().value())
self.positionBarrePresseeSourisIni.setY(self.verticalScrollBar().value())
if PYQT_VERSION_STR >= "4.1.0":
# curseur main fermée
self.setCursor(Qt.ClosedHandCursor)
else: self.setCursor(Qt.SizeAllCursor)
event.accept()
def mouseMoveEvent(self, event):
"Déplacement de l'image dans le QScrollArea quand la souris est pressée"
if self.positionPresseeSourisIni.isNull():
event.ignore()
return
# Nouvelles positions de la barre de défilement (selon x et y)
self.horizontalScrollBar().setValue(self.positionBarrePresseeSourisIni.x() + (self.positionPresseeSourisIni.x() - event.pos().x()))
self.verticalScrollBar().setValue(self.positionBarrePresseeSourisIni.y() + (self.positionPresseeSourisIni.y() - event.pos().y()))
self.horizontalScrollBar().update()
self.verticalScrollBar().update()
event.accept()
def mouseReleaseEvent(self, event):
"Réaffichage du curseur classique de la souris"
self.setCursor(Qt.ArrowCursor)
event.accept()
def setScaleMode(self, mode):
"Choix du mode de redimensionnement"
# Mise à jour du paramètre
self.modeTransformation=mode
def setTailleFenetre(self):
"Affichage taille fenetre"
# Gestion de la taille
#- Si l'image rentre
##- Si l'image est trop grande
# On retaille l'image en gardant le ratio entre
# le min (si l'image ne rentre pas dans le cadre), le max (sinon) de :
# * La largeur de la fenetre
# * La largeur de l'image
# * La hauteur de la fenetre
# * La hauteur de l'image
if (self.preview.height() < self.height()) and (self.preview.width() < self.width()):
width=max(self.preview.width(), self.width())
height=max(self.preview.height(), self.height())
else :
width=min(self.preview.width(), self.width())
height=min(self.preview.height(), self.height())
if self.gif:
self.redimGif(width - 5, height - 5)
else:
resultat = self.preview.get_preview().scaled(width - 5, height - 5, Qt.KeepAspectRatio, self.modeTransformation)
debug(u"Preview : %s, taille : %d, %d" % (self.preview.get_imageName(), self.preview.width(), self.preview.height()))
self.factor = min(float(self.height())/self.preview.height(), float(self.width())/self.preview.width())
#-- On met l'image et on redimensionne le Label pour les images simples
if not self.gif:
self.imageLabel.setPixmap(resultat)
def setTailleReelle(self):
"Fonction d'affichage en taille réelle"
self.preview.origin()
width, height = self.preview.width(), self.preview.height()
# On redimensionne le label à la taille de l'image
if self.gif:
self.redimGif(width, height)
else:
self.imageLabel.setPixmap(self.preview.get_preview())
self.factor = 1
def zoomAvant(self):
"Fonction de zoom avant 25%"
# On redimensionne l'image à 125% de la taille actuelle
factor = 5/4. * self.factor
width = int(self.preview.width() * factor)
height = int(self.preview.height() * factor)
if self.gif:
self.redimGif(width, height)
else:
image = self.preview.get_preview().scaled(width, height, Qt.KeepAspectRatio)
self.imageLabel.setPixmap(image)
self.factor = factor
def zoomArriere(self):
"Fonction de zoom arrière 25%"
# On redimensionne l'image à 75% de la taille actuelle
factor = 3/4. * self.factor
width = int(self.preview.width() * factor)
height = int(self.preview.height() * factor)
if self.gif:
self.redimGif(width, height)
else:
image = self.preview.get_preview().scaled(width, height, Qt.KeepAspectRatio)
self.imageLabel.setPixmap(image)
self.factor = factor
def startPauseGif(self):
"Démarrer/mettre en pause l'animation de l'image gif"
if self.movie.state() == QMovie.NotRunning:
self.movie.start()
else:
self.movie.setPaused(self.movie.state() != QMovie.Paused)
def stopGif(self):
"Arrêter l'animation de l'image gif"
if self.movie.state() != QMovie.NotRunning:
self.movie.stop()
def redimGif(self, width, height):
"""Changer la taille d'affichage du gif en prenant soin d'arrêter et de
reprendre l'animation si nécessaire.
Il y a un petit bogue d'affichage sur la redimension (il disparait en changeant
d'onglet ou de cadre et en revenant.
"""
etatInitial = self.movie.state()
if etatInitial == QMovie.Running:
self.movie.stop()
self.movie.setScaledSize(QSize(width, height))
if etatInitial == QMovie.Running:
self.movie.start()
else:
# On redémarre le gif sinon l'image n'est pas actualisée et reste à la même taille
self.movie.start()
self.movie.stop()
def isGif(self):
"Indique si l'image affichée est un gif. Le test est effectué sur l'extension du fichier"
return self.gif
def setImage(self, img=None, fauxChemin=None, anim=False):
"""Fonction de mise en place de l'image.
Le faux chemin est utile pour dissocier le chemin que verra l'utilisateur
du chemin de l'image affichée. Ils sont différents uniquement lorsqu'une image
composite est affichée (cadres masque alpha 3D et image composite).
L'argument "anim" dit si une image gif doit être animée.
"""
if not img:
img = "Icones" + os.sep + "avant-image.png"
self.setToolTip(_(u"image d'accueil"))
self.setTailleReelle()
return
elif fauxChemin:
self.setToolTip(fauxChemin)
else:
self.setToolTip(img)
# Chargement du gif le cas échéant
if isinstance(img, str) or isinstance(img, unicode):
# En général
extension = os.path.splitext(img)[1]
elif isinstance(img, QString):
# Pour selectWidget.py principalement
extension = "." + QFileInfo(img).suffix()
if extension == ".gif":
self.menuStartPauseGif.setVisible(True)
self.menuStopGif.setVisible(True)
self.gif = 1
self.movie = QMovie(img)
# On démarre le gif de toute façon sinon l'image n'est pas visible
self.movie.start()
if not anim:
self.movie.stop()
self.imageLabel.setMovie(self.movie)
else:
# Pour des images non-gif, on cache les menus d'animation
self.menuStartPauseGif.setVisible(False)
self.menuStopGif.setVisible(False)
self.gif = 0
# Visiblement sous windows la taille du QScrollArea renvoie 0,
# on passe par l'Objet à l'intérieur pour obtenir la taille de l'image à créer
self.preview = EkdPreview(img, self.width(), 0, 10, False, True, True) #(chemin, largeur, qualité, cache?, keepRatio?, magnify? )
# Par défault on charge en taille fenetre
self.setTailleFenetre()
class BoxInterpreter(QObject):
rightClickReceived = pyqtSignal(
object, QPoint) # list of indexes, global window coordinate of click
leftClickReceived = pyqtSignal(object, QPoint)
leftClickReleased = pyqtSignal(object, object)
#boxAdded= pyqtSignal(object, object)
#focusObjectChages= pyqtSignal(object, QPoint)
cursorPositionChanged = pyqtSignal(object)
deleteSelectedItemsSignal = pyqtSignal(
) #send the signal that we want to delete the currently selected item
def __init__(self, navigationInterpreter, positionModel, BoxContr, widget):
'''
Class which interacts directly with the image scene
:param navigationInterpreter:
:param positionModel:
:param BoxContr:
:param widget: The main widget
'''
QObject.__init__(self)
self.baseInterpret = navigationInterpreter
self._posModel = positionModel
self.rubberBand = RedRubberBand(QRubberBand.Rectangle, widget)
self.boxController = BoxContr
self.leftClickReleased.connect(BoxContr.addNewBox)
self.rightClickReceived.connect(BoxContr.onChangedPos)
self.deleteSelectedItemsSignal.connect(BoxContr.deleteSelectedItems)
self.origin = QPoint()
self.originpos = object()
def start(self):
self.baseInterpret.start()
def stop(self):
self.baseInterpret.stop()
def eventFilter(self, watched, event):
pos = [int(i) for i in self._posModel.cursorPos]
pos = [self._posModel.time] + pos + [self._posModel.channel]
#Rectangles under the current point
items = watched.scene().items(QPointF(*pos[1:3]))
items = filter(lambda el: isinstance(el, QGraphicsResizableRect),
items)
#Keyboard interaction
if event.type() == QEvent.KeyPress:
#Switch selection
if event.key() == Qt.Key_N:
#assert items[0]._hovering
#items[0].setZValue(1)
for el in items:
print el.zValue()
if len(items) > 1:
items[-1].setZValue(items[0].zValue() + 1)
items[0].setSelected(False)
items[-1].setSelected(True)
#items[0].setZero()
#Delete element
if event.key() == Qt.Key_Delete:
self.deleteSelectedItemsSignal.emit()
#Pressing mouse and menaging rubber band
if event.type() == QEvent.MouseButtonPress:
if event.button() == Qt.LeftButton:
self.origin = QPoint(event.pos())
self.originpos = pos
self.rubberBand.setGeometry(QRect(self.origin, QSize()))
itemsall = watched.scene().items(QPointF(*pos[1:3]))
itemsall = filter(lambda el: isinstance(el, ResizeHandle),
itemsall)
# if len(itemsall)==0: #show rubber band only if there is no rubbber band
# self.rubberBand.show()
modifiers = QApplication.keyboardModifiers()
if modifiers != Qt.ControlModifier and modifiers != Qt.ShiftModifier and len(
itemsall
) == 0: #show rubber band if Ctrl is not pressed
self.rubberBand.show()
gPos = watched.mapToGlobal(event.pos())
self.leftClickReceived.emit(pos, gPos)
if event.button() == Qt.RightButton:
gPos = watched.mapToGlobal(event.pos())
self.rightClickReceived.emit(pos, gPos)
if event.type() == QEvent.MouseMove:
self.cursorPositionChanged.emit(event.pos())
if not self.origin.isNull():
self.rubberBand.setGeometry(
QRect(self.origin, event.pos()).normalized())
#Relasing the button
if event.type() == QEvent.MouseButtonRelease:
pos = [int(i) for i in self._posModel.cursorPos]
pos = [self._posModel.time] + pos + [self._posModel.channel]
if event.button() == Qt.LeftButton:
self.rubberBand.hide()
self.leftClickReleased.emit(self.originpos, pos)
# Event is always forwarded to the navigation interpreter.
return self.baseInterpret.eventFilter(watched, event)
class MyMainUi(QMainWindow, Ui_MainWindow, QLabel):
def __init__(self, parent=None):
super(MyMainUi, self).__init__(parent)
QLabel.__init__(self, parent)
self.rubberBand = QRubberBand(QRubberBand.Rectangle, self)
self.origin = QPoint()
# Setup UI.
self.setupUi(self)
self.play_pauseButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
self.stopButton.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
# Setup video widget.
self.fileName = None
self.mediaObject = Phonon.MediaObject()
self.videoWidget = self.videoPlayer.videoWidget()
Phonon.createPath(self.mediaObject, self.videoWidget)
self.mediaObject.stateChanged.connect(self.stateChanged)
# Connect seek slider.
self.seekSlider.setMediaObject(self.mediaObject)
# Connect menu options (load, analyze, and exit).
self.actionLoad.triggered.connect(self.loadVideo)
self.actionAnalyze_Area.triggered.connect(self.analyzeArea)
self.actionExit.triggered.connect(self.exit)
# Connect buttons.
self.play_pauseButton.clicked.connect(self.playPause)
self.stopButton.clicked.connect(self.stop)
self.analyzeButton.clicked.connect(self.analyze)
# Selection rubber band
def stateChanged(self, newstate, oldstate):
if self.mediaObject.state() == Phonon.ErrorState:
self.play_pauseButton.setEnabled(False)
self.stopButton.setEnabled(False)
messageBox = QMessageBox()
messageBox.critical(None, 'ERROR',
self.mediaObject.errorString() + '.')
elif self.mediaObject.state() == Phonon.PlayingState:
self.play_pauseButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
self.play_pauseButton.setToolTip('Pause')
else:
self.play_pauseButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
self.play_pauseButton.setToolTip('Play')
def loadVideo(self):
file = QFileDialog.getOpenFileName(self, None, '')
if file != '':
self.mediaObject.setCurrentSource(Phonon.MediaSource(file))
self.play_pauseButton.setEnabled(True)
self.stopButton.setEnabled(True)
self.mediaObject.play()
self.mediaObject.pause()
self.fileName = file
def analyzeArea(self):
# TODO
if self.rangeSlider.isVisible():
self.mediaObject.seek(0)
self.rangeSlider.hide()
self.analyzeButton.hide()
self.seekSlider.show()
self.play_pauseButton.show()
self.stopButton.show()
else:
self.rangeSliderSetup()
self.analyzeButton.show()
print('')
def rangeSliderSetup(self):
self.rangeSlider.setMinimum(0)
self.rangeSlider.setLow(0)
self.mediaObject.seek(0)
if self.mediaObject.totalTime() != 0:
self.rangeSlider.setMaximum(self.mediaObject.totalTime())
self.rangeSlider.setHigh(self.mediaObject.totalTime())
else:
self.rangeSlider.setMaximum(10000)
self.rangeSlider.setHigh(10000)
QtCore.QObject.connect(self.rangeSlider,
QtCore.SIGNAL('sliderMoved(int)'),
self.seekRangeSlider)
self.play_pauseButton.hide()
self.stopButton.hide()
self.seekSlider.hide()
self.rangeSlider.show()
def seekRangeSlider(self, value):
self.mediaObject.seek(value)
def analyze(self):
self.extractClip()
def extractClip(self):
beginning = float(self.rangeSlider.low()) / float(1000)
end = float(self.rangeSlider.high()) / float(1000)
target = self.fileName[:-4] + "[SUBCLIP].avi"
ffmpeg_extract_subclip(self.fileName,
beginning,
end,
targetname=target)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.origin = QPoint(event.pos())
self.rubberBand.setGeometry(QRect(self.origin, QSize()))
self.rubberBand.show()
def mouseMoveEvent(self, event):
if not self.origin.isNull():
self.rubberBand.setGeometry(
QRect(self.origin, event.pos()).normalized())
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
self.rubberBand.hide()
def playPause(self):
if self.mediaObject.state() == Phonon.PlayingState:
self.mediaObject.pause()
# Restart if at end of video.
elif self.mediaObject.remainingTime() == 0:
self.mediaObject.seek(0)
self.mediaObject.play()
else:
self.mediaObject.play()
def stop(self):
self.mediaObject.stop()
self.mediaObject.play()
self.mediaObject.pause()
@staticmethod
def exit():
app.exit()
