class Video(QMainWindow):
def __init__(self):
super(Video, self).__init__()
self.resize(1920, 1080)
# ITEM
self._item = QGraphicsVideoItem()
self._textItem = QGraphicsTextItem()
self._view = QGraphicsView()
self._scene = QGraphicsScene()
self._view.resize(1920, 1080)
self._view.setScene(self._scene)
self._scene.addItem(self._item)
self._scene.addItem(self._textItem)
self._textItem.setPlainText('SRT TEXT')
self._textItem.setDefaultTextColor(Qt.red)
font = self._textItem.font()
font.setPixelSize(50)
self._textItem.setFont(font)
self._view.show()
self._item.setSize(QSizeF(1920, 1080))
self._player = QMediaPlayer(self)
self._player.setMedia(
QMediaContent(
QUrl.fromLocalFile(
'/Users/huangkai/Documents/PycharmProjects/AllTest/Qt插入背景/AddVideos/Videos/yellow.mov'
)))
self._player.setVideoOutput(self._item)
self._player.play()
self.setCentralWidget(self._view)
self._item.setPos(400, 500)
# BUTTON
self._btn = QPushButton(self)
self._btn.resize(100, 50)
self._btn.move(500, 500)
self._btn.setText('test')
self._btn.clicked.connect(self._change_text)
def _change_text(self):
self._textItem.setPlainText('Fighting')
class eyeTrackingWidget(QtWidgets.QWidget):
def __init__(self, *args, **kwargs):
QtWidgets.QWidget.__init__(self, *args, **kwargs)
##################### eye tracking #####################
self.audience_eye_tracking_dic = {}
self.eye_track_dic = {}
self.elements = {}
self.eye_track_frame_rate = 10
self.trial_lapse = 2000
self.eye_tracking_width = 1024 ##eye tracking hardware resolution
self.eye_tracking_height = 768 ##eye tracking hardware resolution
self.view_width = 1184 ##QGraphicsView resolution
self.view_height = 666 ##QGraphcsView
##################### eye tracking #####################
####### DO NOT TOUCH #######
self.loaded = 0
#self.tl = timeline.timeline(self)
#self.tl = timeline.timeline(self)
#self.layout.addChildWidget(self.tl)
# player.setInterval(self.eye_track_frame_rate)
# timer.timeout.connect(self.draw_eye_tracking)
####### DO NOT TOUCH #######
###############################
self.view = QtWidgets.QGraphicsView()
self.view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setViewport(PyQt5.QtOpenGL.QGLWidget())
self.view.setFixedSize(self.view_width + 2, self.view_height + 2)
self.view.setGeometry(0, 0, self.view_width, self.view_height)
self.videoItem = QGraphicsVideoItem()
# MUST setsize that is half the size of the GraphicsView
# Most likey a bug in Qt's implementation on Mac OS X
self.videoItem.setSize(
QtCore.QSizeF(self.view_width / 2, self.view_height / 2))
self.player = QM.QMediaPlayer()
self.player.setVideoOutput(self.videoItem)
self.scene = QtWidgets.QGraphicsScene()
self.scene.addItem(self.videoItem)
self.view.setScene(self.scene)
self.scene.setSceneRect(0, 0, self.view_width, self.view_height)
self.videoItem.setPos(0, 0)
###############################
self.layout = QtWidgets.QVBoxLayout(self)
self.layout.addWidget(self.view)
self.createUI()
self.view.show()
def createUI(self):
# video position slider
self.positionSlider = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
self.positionSlider.setStyleSheet(
"QSlider::groove:horizontal {background-color:grey;}"
"QSlider::handle:horizontal {background-color:black; height:8px; width: 8px;}"
)
self.positionSlider.sliderMoved.connect(self.setPosition)
#self.positionSlider.valueChanged.connect(self.setPosition)
# play button
self.hbuttonbox = QtWidgets.QHBoxLayout()
self.playbutton = QtWidgets.QPushButton("Play")
self.hbuttonbox.addWidget(self.playbutton)
self.playbutton.clicked.connect(self.play_pause)
self.openbutton = QtWidgets.QPushButton("Open")
self.hbuttonbox.addWidget(self.openbutton)
self.openbutton.clicked.connect(self.open_file)
self.openbutton2 = QtWidgets.QPushButton("Open EYE")
self.hbuttonbox.addWidget(self.openbutton2)
self.openbutton2.clicked.connect(self.open_eye)
self.openbutton3 = QtWidgets.QPushButton("Open TL")
self.hbuttonbox.addWidget(self.openbutton3)
self.openbutton3.clicked.connect(self.open_timeline)
self.openbutton4 = QtWidgets.QPushButton("Open EEG")
self.hbuttonbox.addWidget(self.openbutton4)
self.comboLabel = QtWidgets.QLabel("Select objects:")
self.combobox = QtWidgets.QComboBox(self)
self.comboboxDelegate = utility.SubclassOfQStyledItemDelegate()
self.combobox.setItemDelegate(self.comboboxDelegate)
self.combobox.setSizeAdjustPolicy(0)
self.hbuttonbox.addWidget(self.comboLabel)
self.hbuttonbox.addWidget(self.combobox)
self.hbuttonbox.addStretch(1)
self.layout.addWidget(self.positionSlider)
self.layout.addLayout(self.hbuttonbox)
self.player.setNotifyInterval(1000 / self.eye_track_frame_rate)
self.player.positionChanged.connect(self.updateUI)
self.player.positionChanged.connect(self.updateEyeTracking)
self.player.durationChanged.connect(self.setRange)
self.player.stateChanged.connect(self.setButtonCaption)
self.setLayout(self.layout)
def setButtonCaption(self, state):
if self.player.state() == QM.QMediaPlayer.PlayingState:
self.playbutton.setText("Pause")
else:
self.playbutton.setText("Play")
def open_file(self):
home = str(Path.home())
filename, _ = QtWidgets.QFileDialog.getOpenFileName(
self, "Open File", home)
if not filename:
return
url = QtCore.QUrl.fromLocalFile(filename)
content = QM.QMediaContent(url)
self.player.setMedia(content)
self.playbutton.setText("Play")
def open_eye(self):
home = str(Path.home())
filenames, _ = QtWidgets.QFileDialog.getOpenFileNames(
self, "Open EYE", home)
print("%s, %s" % (filenames, len(filenames)))
if not filenames:
return
object_list = []
self.audience_eye_tracking_dic = {}
self.eye_track_dic = {}
for filename in filenames:
object = os.path.split(filename)[-1].split('_')[0]
self.create_eye_tracking_reference_dict(
pandas.read_excel(str(filename)), object)
object_list.append(object)
self.addSelectArea(object_list)
def play_pause(self):
if self.player.state() == QM.QMediaPlayer.PlayingState:
self.player.pause()
else:
self.player.play()
def setPosition(self, position):
self.positionSlider.setValue(position)
self.player.setPosition(position)
def setRange(self):
self.positionSlider.setRange(0, self.player.duration())
def updateUI(self, position):
self.positionSlider.setValue(position)
def updateEyeTracking(self, position):
if len(self.eye_track_dic.keys()) == 0: # or self.player.state() != 2:
return
self.draw_eye_tracking()
def addSelectArea(self, objects):
self.player.pause()
for k in self.elements.keys():
self.removeElement(self.elements[k], k)
self.elements = {}
self.model = QtGui.QStandardItemModel(len(objects) + 1,
1) # 5 rows, 2 col
firstItem = QtGui.QStandardItem("---- Select area(s) ----")
firstItem.setBackground(QtGui.QBrush(QtGui.QColor(200, 200, 200)))
firstItem.setSelectable(False)
self.model.setItem(0, 0, firstItem)
num = 0
for obj in objects:
num += 1
item = QtGui.QStandardItem(obj)
item.setFlags(QtCore.Qt.ItemIsUserCheckable
| QtCore.Qt.ItemIsEnabled)
itemColor = QtGui.QColor(random.randint(0, 255),
random.randint(0, 255),
random.randint(0, 255))
item.setBackground(itemColor)
if num <= 2:
item.setData(QtCore.Qt.Checked, QtCore.Qt.CheckStateRole)
self.elements[item.text()] = {
'dot': None,
'lines': [],
'color': itemColor
}
else:
item.setData(QtCore.Qt.Unchecked, QtCore.Qt.CheckStateRole)
self.model.setItem(num, 0, item)
self.model.itemChanged.connect(self.update_objects)
self.combobox.setModel(self.model)
def removeElement(self, element, name):
for line in element['lines']:
self.scene.removeItem(line)
del line
self.scene.removeItem(element['dot'])
del element['dot']
# del element['color']
self.elements.pop(name)
def update_objects(self, item):
if item.checkState() == 0:
self.removeElement(self.elements[item.text()], item.text())
else:
self.elements[item.text()] = {
'dot': None,
'lines': [],
'color': item.background().color()
}
def draw_dot_line(self, v, obj):
pos = v['pos']
rad = v['rad']
if self.elements[obj]['dot'] is not None:
self.elements[obj]['dot'].setRect(QtCore.QRectF(0, 0, rad, rad))
else:
self.elements[obj]['dot'] = self.scene.addEllipse(
QtCore.QRectF(0, 0, rad, rad), QtGui.QPen(QtCore.Qt.red),
QtGui.QBrush(self.elements[obj]['color']))
self.elements[obj]['dot'].setPos(
QtCore.QPoint(pos[0] - rad / 2, pos[1] - rad / 2))
j = 0
for i in range(len(v['lines'])):
j = i
if i >= len(self.elements[obj]['lines']):
self.elements[obj]['lines'].append(
self.scene.addLine(
QtCore.QLineF(v['lines'][i][0][0], v['lines'][i][0][1],
v['lines'][i][1][0],
v['lines'][i][1][1]),
QtGui.QPen(self.elements[obj]['color'])))
else:
self.elements[obj]['lines'][i].setLine(
QtCore.QLineF(v['lines'][i][0][0], v['lines'][i][0][1],
v['lines'][i][1][0], v['lines'][i][1][1]))
if len(self.elements[obj]['lines']) > j:
for line in self.elements[obj]['lines'][j + 1:-1]:
self.scene.removeItem(line)
del line
def resolution_transfer(self, x, y, duration):
return [x / self.eye_tracking_width * (self.view_width + 2),\
y / self.eye_tracking_height * (self.view_height + 2), \
3 + duration / 20.0]
def create_eye_tracking_reference_dict(self, excel, object):
self.audience_eye_tracking_dic[object] = {
'pos': [],
'rad': 0,
'lines': []
}
self.eye_track_window = 1000 / self.eye_track_frame_rate
self.eye_track_dic[object] = []
last_one = int(excel['CURRENT_FIX_START'][521] / self.eye_track_window)
head = 0
for i in range(last_one):
start_time = i * self.eye_track_window
updated_flag = False
while head < len(excel['CURRENT_FIX_START'].index):
if excel['CURRENT_FIX_START'][head] > start_time:
break
if excel['CURRENT_FIX_START'][
head] <= start_time and start_time <= excel[
'CURRENT_FIX_END'][head]:
self.eye_track_dic[object].append(
self.resolution_transfer(
excel['CURRENT_FIX_X'][head],
excel['CURRENT_FIX_Y'][head],
excel['CURRENT_FIX_DURATION'][head]))
updated_flag = True
break
head += 1
if not updated_flag:
if len(self.eye_track_dic[object]) > 0:
self.eye_track_dic[object].append(
self.eye_track_dic[object][-1])
else:
self.eye_track_dic[object].append([])
# print "no positions!"
# print self.eye_track_dic
def draw_eye_tracking(self, clean_flag=False):
media_time = self.player.position()
for k in self.elements:
v = self.audience_eye_tracking_dic[k]
eye_tracking_window_index = int(media_time / self.eye_track_window)
if eye_tracking_window_index >= len(self.eye_track_dic[k]) \
or len(self.eye_track_dic[k][eye_tracking_window_index]) < 3:
continue
v['pos'] = self.eye_track_dic[k][eye_tracking_window_index][0:2]
v['rad'] = self.eye_track_dic[k][eye_tracking_window_index][2]
v['lines'] = []
if len(v['pos']) == 2:
for line_num in range(
int(self.trial_lapse / self.eye_track_window)):
if eye_tracking_window_index - line_num - 1 >= 0 and len(
self.eye_track_dic[k][eye_tracking_window_index -
line_num - 1]) == 3:
v['lines'].append([
self.eye_track_dic[k][eye_tracking_window_index -
line_num - 1],
self.eye_track_dic[k][eye_tracking_window_index -
line_num]
])
self.draw_dot_line(v, k)
##################### eye tracking #####################
def open_timeline(self):
home = str(Path.home())
filename, _ = QtWidgets.QFileDialog.getOpenFileName(
self, "Open TL", home)
if not filename:
return
self.tldata = pandas.read_excel(str(filename))
self.tldata = self.tldata.as_matrix()
self.makeArr(self.tldata)
self.loaded = 1
self.update()
self.randArr = np.random.randint(0, 256, size=(3, 15))
def makeArr(self, tldata):
startX = 12.0
pixLength = 1168.0
self.rows, self.cols = self.tldata.shape
dim = (self.rows, 6)
self.tldata = np.concatenate((self.tldata, np.zeros((dim))), axis=1)
#start_millisec
self.tldata[:, 2] = self.tldata[:, 0] * 1000.0
#end_millisec
self.tldata[:, 3] = self.tldata[:, 1] * 1000.0
#diff_millisec
self.tldata[:, 4] = self.tldata[:, 3] - self.tldata[:, 2]
#X1 position
self.tldata[:, 5] = startX + (self.tldata[:, 2] /
self.player.duration()) * pixLength
#X2 position
self.tldata[:, 6] = self.tldata[:, 5] + (
self.tldata[:, 4] / self.player.duration()) * pixLength
#width in pixels
self.tldata[:, 7] = self.tldata[:, 6] - self.tldata[:, 5]
def paintEvent(self, e):
if self.loaded == 1:
qp = QtGui.QPainter()
qp.begin(self)
self.colorize(qp)
qp.end()
def colorize(self, qp):
Y = 700
#print("tl loaded:", self.tl_loaded)
for i in range(self.rows):
k = i % 15
qp.fillRect(
QtCore.QRectF(self.tldata[i, 6], Y, self.tldata[i, 7], 5),
QtGui.QColor(self.randArr[0, k], self.randArr[1, k],
self.randArr[2, k]))
class jaabaGUI(QMainWindow):
""" controller for the blob labeling GUI"""
def __init__(self,parent=None):
QMainWindow.__init__(self,parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
#add new slider
# self.positionSlider=QSlider(Qt.Horizontal)
# self.positionSlider.setGeometry (800,800,100,30)
# self.positionSlider.setRange(0, 0)
# self.positionSlider.sliderMoved.connect(self.setPosition)
#setup Video
#video player
self.mediaPlayer1 = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer2 = QMediaPlayer(None, QMediaPlayer.VideoSurface)
#self.mediaPlayer.metaDataChanged.connect(self.metaDataChanged)
self.mediaPlayer1.durationChanged.connect(self.durationChanged)
self.mediaPlayer1.positionChanged.connect(self.positionChanged)
self.mediaPlayer2.positionChanged.connect(self.positionChanged)
#visualizetion
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
#self.scene.setBackgroundBrush(Qt.black)
self.videoItem1 = QGraphicsVideoItem()
self.videoItem2 = QGraphicsVideoItem()
self.scene.addItem(self.videoItem1)
self.scene.addItem(self.videoItem2)
self.mediaPlayer1.setVideoOutput(self.videoItem1)
self.mediaPlayer2.setVideoOutput(self.videoItem2)
#slide bar
print self.ui.horizontalSlider
self.ui.horizontalSlider.setRange(0, 0)
self.ui.horizontalSlider.sliderMoved.connect(self.setPosition)
# self.ui.horizontalSlider.sliderPressed.connect(self.sliderPressed)
#print self.ui.graphicsView.width()/2,self.ui.graphicsView.height()
#self.videoItem1.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height()))
#self.videoItem2.setSize(QSizeF(self.ui.graphicsView.width()*10,self.ui.graphicsView.height()*10))
# self.videoItem2.setSize(graphicsView.size())
#self.videoItem2.setOffset(QPointF(500,500))
#self.videoItem2.setOffset(QPointF(self.ui.graphicsView.width()/2,0))
#self.videoItem2.setPos(QPointF(0,0))
# print self.ui.graphicsView.width(), self.ui.graphicsView.height()
# print self.ui.graphicsView.size()
# print self.videoItem2.boundingRect().width(), self.videoItem2.boundingRect().height()
# print self.ui.graphicsView.sceneRect()
#self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
#callbacks
self.ui.actionQuit.triggered.connect(self.quit)
self.ui.actionLoad_Project.triggered.connect(self.loadVideo)
#self.ui.buttonPlay.clicked[bool].connect(self.setToggleText)
self.ui.buttonPlay.clicked.connect(self.play)
#print self.ui.graphicsView.sizeHint()
#initialization
self.loaded = False
self.videoFilename = None
self.frame_count=None
self.width=None
self.height=None
self.frame_trans=None
# ###actions starts from here###
def quit(self):
QApplication.quit()
def loadVideo(self):
self.writeLog("Loading video...")
self.videoFilename = QFileDialog.getOpenFileName(self, 'Open File', '.')[0]
if not self.videoFilename:
self.writeLog("User cancelled - no video loaded")
return
else:
cap=cv2.VideoCapture(self.videoFilename)
self.frame_count=cap.get(cv2.CAP_PROP_FRAME_COUNT)
self.width=cap.get(3)
self.height=cap.get(4)
self.mediaPlayer2.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename )))
self.mediaPlayer1.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename )))
self.ui.buttonPlay.setEnabled(True)
# self.mediaPlayer2.setVideoOutput(self.videoItem2)
# self.mediaPlayer1.setVideoOutput(self.videoItem1)
# size= self.videoItem2.nativeSize()
# print size
#print self.mediaPlayer.duration()
#print self.mediaPlayer.metaData()
self.writeLog("Video loaded!")
def play(self):
self.videoItem1.setAspectRatioMode(0)
self.videoItem2.setAspectRatioMode(0)
self.scene.setSceneRect(0,0,self.ui.graphicsView.width(),self.ui.graphicsView.height())
self.videoItem1.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height()))
self.videoItem2.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height()))
self.videoItem1.setPos(QPointF(0,0))
self.videoItem2.setPos(QPointF(self.ui.graphicsView.width()/2,0))
#self.ui.graphicsView.setGeometry(0,0, 600,800)
#print 'graphicsView size', self.ui.graphicsView.size()
#print 'graphicsScene size', self.scene.sceneRect()
#self.videoItem2.setSize(QSizeF(1000,300))
#print 'graphicsVideoItem size',self.videoItem2.size()
# print 'item x',self.videoItem2.scenePos().x()
# print 'item y', self.videoItem2.scenePos().y()
# print 'item x',self.videoItem1.scenePos().x()
# print 'item y', self.videoItem1.scenePos().y()
if self.mediaPlayer1.state() == QMediaPlayer.PlayingState:
self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(PyQt5.QtWidgets.QStyle.SP_MediaPlay))
self.ui.buttonPlay.setText("Play")
self.mediaPlayer1.pause()
self.writeLog("Video paused")
else:
self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(PyQt5.QtWidgets.QStyle.SP_MediaPause))
self.ui.buttonPlay.setText("Stop")
self.mediaPlayer1.play()
self.writeLog("Playing video")
if self.mediaPlayer2.state() == QMediaPlayer.PlayingState:
self.mediaPlayer2.pause()
else:
self.mediaPlayer2.play()
#size= self.videoItem2.nativeSize()
# print self.mediaPlayer.duration()
#print self.mediaPlayer.metaData()
# print self.ui.graphicsView.width(), self.ui.graphicsView.height()
# print self.ui.graphicsView.size()
# print self.videoItem2.boundingRect().width(), self.videoItem2.boundingRect().height()
# print self.ui.graphicsView.sceneRect()
# print self.scene.sceneRect()
# print self.ui.graphicsView.sizeHint()
def setPosition(self, position):
self.mediaPlayer1.setPosition(position)
self.mediaPlayer2.setPosition(position)
# when position of media changed, set slider and text box accordingly.
def positionChanged(self, position):
self.ui.horizontalSlider.setValue(position)
if isinstance(self.frame_trans,float):
# print type(position),position
# print type(self.frame_trans),self.frame_trans
# print position/self.frame_trans
self.ui.lineEdit.setText(str(int(round(position/self.frame_trans,0))))
self.writeLog(str(position))
def durationChanged(self, duration):
self.ui.horizontalSlider.setRange(0, duration)
self.frame_trans=self.mediaPlayer1.duration()/self.frame_count
print self.frame_trans
def writeLog(self,text):
self.ui.log.setText(text)
class VideoScene(QGraphicsScene):
regionSelected = Signal(QRect)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.videoItem = QGraphicsVideoItem()
self.videoItem.setPos(0, 0)
self.videoItem.nativeSizeChanged.connect(self.videoSizeChanged)
self.addItem(self.videoItem)
self.rectangle = QGraphicsRectItem()
self.rectangle.setPen(QColor(0, 122, 217))
self.addItem(self.rectangle)
def videoSizeChanged(self, size: QSizeF):
logging.debug("%s", size)
if not size.isEmpty():
self.videoItem.setSize(size)
self.setSceneRect(self.videoItem.boundingRect())
self.clearSelection()
def clearSelection(self) -> None:
self.rectangle.setRect(QRectF())
self.regionSelected.emit(self.selection)
@property
def selection(self) -> QRect:
return self.rectangle.rect().toRect()
@staticmethod
def coerceInside(point: QPointF, rect: QRectF):
return QPointF(
min(max(point.x(), rect.left()), rect.right()),
min(max(point.y(), rect.top()), rect.bottom()),
)
def coerceInsideVideo(self, point: QPointF):
return self.coerceInside(point, self.videoItem.boundingRect())
def mousePressEvent(self, event: QGraphicsSceneMouseEvent) -> None:
self.startPos = self.coerceInsideVideo(event.scenePos())
return super().mousePressEvent(event)
def mouseMoveEvent(self, event: QGraphicsSceneMouseEvent) -> None:
endPos = self.coerceInsideVideo(event.scenePos())
self.rectangle.setRect(QRectF(self.startPos, endPos).normalized())
return super().mouseMoveEvent(event)
def mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent) -> None:
logging.info("Selection: %s", self.selection)
super().mouseReleaseEvent(event)
self.regionSelected.emit(self.selection)
def paintGrid(self, painter: QPainter, rect: QRectF, gridSize: int):
left, top, right, bottom = rect.getCoords()
x_min = (int(left - 1) // gridSize + 1) * gridSize
y_min = (int(top - 1) // gridSize + 1) * gridSize
x_max = (int(right) // gridSize) * gridSize
y_max = (int(bottom) // gridSize) * gridSize
# logging.debug(
# "x=(%s<=%s..%s<=%s) y=(%s<=%s..%s<=%s)",
# *(left, x_min, x_max, right),
# *(top, y_min, y_max, bottom)
# )
painter.setPen(QPen(Qt.gray, 2))
painter.drawLines(QLineF(0, top, 0, bottom), QLineF(left, 0, right, 0))
painter.setPen(QPen(Qt.gray, 1))
painter.drawLines(
QLineF(x, top, x, bottom)
for x in range(x_min, x_max + 1, gridSize) if x)
painter.drawLines(
QLineF(left, y, right, y)
for y in range(y_min, y_max + 1, gridSize) if y)
def drawBackground(self, painter: QPainter, rect: QRectF) -> None:
super().drawBackground(painter, rect)
self.paintGrid(painter, rect, 20)
class jaabaGUI(QMainWindow):
""" controller for the blob labeling GUI"""
def __init__(self,parent=None):
self.debugMode = True
self.debugVideoPath = '/Users/071cht/Desktop/Lab/jaabagui/testt.mjpeg.avi'
QMainWindow.__init__(self,parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.installEventFilter(self)
self.setFocusPolicy(Qt.StrongFocus)
#add new slider
# self.positionSlider=QSlider(Qt.Horizontal)
# self.positionSlider.setGeometry (800,800,100,30)
# self.positionSlider.setRange(0, 0)
# self.positionSlider.sliderMoved.connect(self.setPosition)
#setup Video
#video player
self.mediaPlayer1 = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer2 = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer2.setNotifyInterval(10)
#self.mediaPlayer.metaDataChanged.connect(self.metaDataChanged)
self.mediaPlayer1.durationChanged.connect(self.durationChanged)
self.mediaPlayer1.positionChanged.connect(self.positionChanged)
self.mediaPlayer2.positionChanged.connect(self.positionChanged)
#self.mediaPlayer2.positionChanged.connect(self.paintEvent)
#visualizetion
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
#self.scene.setBackgroundBrush(Qt.black)
self.videoItem1 = QGraphicsVideoItem()
self.videoItem2 = Video()
self.scene.addItem(self.videoItem1)
self.scene.addItem(self.videoItem2)
self.mediaPlayer1.setVideoOutput(self.videoItem1)
self.mediaPlayer2.setVideoOutput(self.videoItem2)
#slider bar
self.ui.horizontalSlider.setRange(0, 0)
self.ui.horizontalSlider.sliderMoved.connect(self.setPosition)
# self.ui.horizontalSlider.sliderPressed.connect(self.sliderPressed)
#draw on video
self.flyCanvas= TargetView()
self.scene.addItem(self.flyCanvas)
#give reference to target view
self.flyCanvas.setWindowReference(self)
#lineEdit signals:
self.ui.lineEdit.returnPressed.connect(self.lineEditChanged)
#callbacks
self.ui.actionQuit.triggered.connect(self.quit)
self.ui.actionLoad_Project.triggered.connect(self.loadVideo)
self.ui.actionImport_Labels.triggered.connect(self.loadLabels)
#self.ui.buttonPlay.clicked[bool].connect(self.setToggleText)
self.ui.buttonPlay.clicked.connect(self.play)
self.ui.actionSave.triggered.connect(self.saveLabels)
## print self.ui.graphicsView.sizeHint()
#behavior Button
self.ui.buttonBehavior.clicked.connect(self.behaviorButtonClick)
self.ui.buttonNone.clicked.connect(self.noneButtonClick)
#initialization
self.loaded = False
self.videoFilename = None
self.frame_count=None
self.width=None
self.height=None
self.frame_trans=None
self.previous_frame=0
self.current_frame=0
self.behaviorButtonStart = False
self.noneButtonStart = False
self.currentFly=1
#initialize flyInfo
#self.setCurrentFly(self.currentFly)
# register flyid changed callback
self.flyCanvas.onCurrentFlyIdChanged(self.currentFlyIdChangedCallback)
self.flyCanvas.setCurrentFlyId(self.currentFly)
# when double click on video, change fly id in target view
self.videoItem2.onDoubleClick(self.flyCanvas.setCurrentFlyIdByXY)
########################
# DEBUG PART HERE!!!!! #
########################
if (self.debugMode):
self.debugLoadVideo()
# add label UI related when load video
def showEvent(self, evt):
super(jaabaGUI, self).showEvent(evt)
##### HERE THE WINDOW IS LOADED!!!!!!!!
# self.loadLabelUI()
def loadLabelUI(self):
#labels
self.labelScene = QGraphicsScene()
self.ui.graphLabels.setScene(self.labelScene)
# the size is only accurate after the window fully displayed
labelUIWidth = self.ui.graphLabels.width()
labelUIHeight = self.ui.graphLabels.height()-1
self.labelScene.setSceneRect(0,0,labelUIWidth,labelUIHeight)
self.labelUI = LabelUI()
# visiableWidth = 850
# height = 30
# visiableFrameNum = 850
self.labelUI.setWidthPerFrame(850.0/850.0)
# print '850/500',850.0/850.0b
# print 'length_perframe is ', self.labelUI.widthPerFrame
# 850 is the original length of graphLabel
total_length= self.labelUI.widthPerFrame * self.frame_count
self.labelUI.setVisiableSize(total_length,30)
# set start position
self.labelUI.setPos(labelUIWidth/2,0)
print 'frame_count is ', self.frame_count
print 'total length is', total_length
self.labelScene.addItem(self.labelUI)
# middle line ui
self.labelUIMiddleLine = LabelUIMiddleLine()
self.labelScene.addItem(self.labelUIMiddleLine)
self.labelUIMiddleLine.setPos(labelUIWidth/2,0)
# self.labelUI.setPos(QPointF(-100,0))
self.writeLog('Label UI loaded')
def eventFilter(self, obj, event):
if (event.type() == PyQt5.QtCore.QEvent.KeyPress):
# http://qt-project.org/doc/qt-4.8/qt.html#Key-enum
key = event.key()
if (key == Qt.Key_Up) :
curr_frame= int(float(self.ui.lineEdit.text()))
curr_frame= curr_frame-30
media_position= int(round(curr_frame*self.frame_trans))
# print curr_frame, media_position
self.mediaPlayer1.setPosition(media_position)
self.mediaPlayer2.setPosition(media_position)
# print 'down -30'
elif (key == Qt.Key_Right):
curr_frame= int(float(self.ui.lineEdit.text()))
# print 'right +1'
# print curr_frame
curr_frame= curr_frame+1
media_position= int(round(curr_frame*self.frame_trans))
# print 'curr_frame',curr_frame
# print 'frame_trans',self.frame_trans
# print ' curr_frame*self.frame_trans',curr_frame*self.frame_trans
# print 'media_position',media_position
# print curr_frame, media_position
self.mediaPlayer1.setPosition(media_position)
self.mediaPlayer2.setPosition(media_position)
# self.mediaPlayerPositionChanged(media_position)
elif (key == Qt.Key_Left):
curr_frame= int(float(self.ui.lineEdit.text()))
curr_frame= curr_frame-1
media_position= int(round(curr_frame*self.frame_trans))
self.mediaPlayer1.setPosition(media_position)
self.mediaPlayer2.setPosition(media_position)
# print 'left -1'
elif (key == Qt.Key_Down):
curr_frame= int(float(self.ui.lineEdit.text()))
curr_frame= curr_frame+30
media_position= int(round(curr_frame*self.frame_trans))
self.mediaPlayer1.setPosition(media_position)
self.mediaPlayer2.setPosition(media_position)
# print 'up +30'
return True
return False
# ###actions starts from here###
def quit(self):
QApplication.quit()
def loadVideo(self):
# print QMediaPlayer.supportedMimeTypes()
self.writeLog("Loading video...")
self.videoFilename = QFileDialog.getOpenFileName(self, 'Open File', '.')[0]
if not self.videoFilename:
self.writeLog("User cancelled - no video loaded")
return
else:
cap=cv2.VideoCapture(self.videoFilename)
self.frame_count=cap.get(cv2.CAP_PROP_FRAME_COUNT)
self.width=cap.get(3)
self.height=cap.get(4)
self.mediaPlayer2.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename )))
self.mediaPlayer1.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename )))
self.ui.buttonPlay.setEnabled(True)
# self.mediaPlayer2.setVideoOutput(self.videoItem2)
# self.mediaPlayer1.setVideoOutput(self.videoItem1)
# size= self.videoItem2.nativeSize()
# # print size
## print self.mediaPlayer.duration()
## print self.mediaPlayer.metaData()
self.writeLog("Video loaded!")
# init label related ui
self.loadLabelUI()
def debugLoadVideo(self):
self.videoFilename = self.debugVideoPath
cap=cv2.VideoCapture(self.videoFilename)
self.frame_count=cap.get(cv2.CAP_PROP_FRAME_COUNT)
self.width=cap.get(3)
self.height=cap.get(4)
self.mediaPlayer2.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename )))
self.mediaPlayer1.setMedia(QMediaContent(QUrl.fromLocalFile(self.videoFilename )))
self.ui.buttonPlay.setEnabled(True)
self.writeLog("Video loaded!")
QTimer.singleShot(1000, self.loadLabelUI)
def play(self):
self.videoItem1.setAspectRatioMode(0)
self.videoItem2.setAspectRatioMode(0)
self.scene.setSceneRect(0,0,self.ui.graphicsView.width(),self.ui.graphicsView.height())
self.videoItem1.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height()))
self.videoItem2.setSize(QSizeF(self.ui.graphicsView.width()/2,self.ui.graphicsView.height()))
self.videoItem1.setPos(QPointF(0,0))
self.videoItem2.setPos(QPointF(self.ui.graphicsView.width()/2,0))
self.flyCanvas.setPos(QPointF(self.ui.graphicsView.width()/2,0))
# custom function setXYScale
self.videoItem2.setXYScale(self.width,self.height,self.ui.graphicsView.width()/2,self.ui.graphicsView.height())
self.flyCanvas.setXYScale(self.width,self.height,self.ui.graphicsView.width()/2,self.ui.graphicsView.height())
if self.mediaPlayer1.state() == QMediaPlayer.PlayingState:
self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(PyQt5.QtWidgets.QStyle.SP_MediaPlay))
self.ui.buttonPlay.setText("Play")
self.mediaPlayer1.pause()
self.writeLog("Video paused")
else:
self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(PyQt5.QtWidgets.QStyle.SP_MediaPause))
self.ui.buttonPlay.setText("Stop")
self.mediaPlayer1.play()
self.writeLog("Playing video")
if self.mediaPlayer2.state() == QMediaPlayer.PlayingState:
self.mediaPlayer2.pause()
else:
self.mediaPlayer2.play()
def loadLabels(self):
self.writeLog("Loading labels from file...")
self.labelFilename = QFileDialog.getOpenFileName(self, 'Open File', '.')[0]
self.labelUI.labelData = pickle.load(open(self.labelFilename,"rb"))
self.writeLog("Label loaded from file:" + self.labelFilename)
def saveLabels(self):
# Now it can only save to current file. Will add an poput window to choose path later
pickle.dump( self.labelUI.labelData, open( "newLabels.p", "wb" ) )
def setPosition(self, position):
self.mediaPlayer1.setPosition(position)
self.mediaPlayer2.setPosition(position)
# when position of media changed, set slider and text box accordingly.
def positionChanged(self, position):
#test change labelui position
# self.labelUI.startLabel();
# self.labelUI.update()
previous_frame= self.previous_frame
curr_frame= int(round(position/self.frame_trans))
self.current_frame=curr_frame
frame_change= previous_frame-curr_frame
move_width= frame_change * self.labelUI.widthPerFrame
self.previous_frame= curr_frame
self.labelUI.moveBy(move_width,0)
self.labelUI.setCurrentFrame(curr_frame)
# enforce labelUI paint once
self.labelUI.update()
# self.labelUI.setPos(self.labelUI.mapToParent(1,0));
# self.labelUI.update()
# # print 'triggered position'
# # print position
# # print 'cur position'
# # print self.mediaPlayer2.position()
self.updateLineEdit(position)
self.updateSliderAndGraph(position)
# self.ui.horizontalSlider.setValue(position)
# if isinstance(self.frame_trans,float):
# # # print type(position),position
# # # print type(self.frame_trans),self.frame_trans
# # # print position/self.frame_trans
# self.ui.lineEdit.setText(str(int(round(position/self.frame_trans))))
# self.flyCanvas.getFrame(int(round(position/self.frame_trans)))
# self.flyCanvas.isManualCalled = True;
# self.flyCanvas.update()
# self.writeLog(str(position))
# # self.updateMediaControlUI(position)
# # self.flyCanvas.update()
def updateSliderAndGraph(self, position):
self.ui.horizontalSlider.setValue(position)
if isinstance(self.frame_trans,float):
self.flyCanvas.getFrame(int(round(position/self.frame_trans)))
self.flyCanvas.isManualCalled = True
self.flyCanvas.update()
#self.writeLog(str(position))
def updateLineEdit(self, position):
# # print self.width
# # print self.height
if isinstance(self.frame_trans,float):
# # print type(position),position
# # print type(self.frame_trans),self.frame_trans
# # print position/self.frame_trans
self.ui.lineEdit.setText(str(int(round(position/self.frame_trans))))
def durationChanged(self, duration):
self.ui.horizontalSlider.setRange(0, duration)
self.frame_trans=self.mediaPlayer1.duration()/self.frame_count
## print self.frame_trans
#def eventFilter(self,source,event):
#if (event.type()==PyQt5.QtCore.QEvent.MousePress and source is self.videoItem2):
# pos=event.pos()
# # print('mouse position: (%d,%d)' % (pos.x(),pos.y()))
# return PyQt5.QtGui.QWidget.eventFilter(self, source, event)
def writeLog(self,text):
self.ui.log.setText(text)
# def eventFilter (self.ui.lineEdit,event):
# if event.type()==PyQt5.QtCore.QEvent
def lineEditChanged(self):
#set position of media
curr_frame= int(float(self.ui.lineEdit.text()))
media_position= int(round(curr_frame*self.frame_trans))
self.mediaPlayer1.setPosition(media_position)
self.mediaPlayer2.setPosition(media_position)
# print 'setPosition'
# print media_position
# print 'after set'
# print self.mediaPlayer2.position()
# self.updateSliderAndGraph(media_position)
def behaviorButtonClick(self):
# flip flag
self.behaviorButtonStart = not self.behaviorButtonStart
# check click to start or stop
if (self.behaviorButtonStart):
# start labeling
self.labelUI.startLabel(self.ui.comboBox.currentIndex(),'',self.current_frame)
self.writeLog('start labeling')
else:
# stop lableing
self.labelUI.stopLabel()
self.writeLog('stop labeling')
def noneButtonClick(self):
# flip flag
self.noneButtonStart = not self.noneButtonStart
# check click to start or stop
if (self.noneButtonStart):
# start labeling
self.labelUI.startLabel(self.ui.comboBox.currentIndex(),'_none',self.current_frame)
self.writeLog('start labeling')
else:
# stop lableing
self.labelUI.stopLabel()
self.writeLog('stop labeling')
# set CurrentFly when fly changed!
def setCurrentFly(self,fly):
self.currentFly = fly
self.ui.flyInfo.setPlainText('FlyID:' + str(self.currentFly))
self.flyCanvas.currentFly=fly
def currentFlyIdChangedCallback(self,fly):
print 'callback!!!!!';
self.currentFly = fly
self.ui.flyInfo.setPlainText('FlyID:' + str(self.currentFly))
class jaabaGUI(QMainWindow):
""" controller for the blob labeling GUI"""
def __init__(self, parent=None):
self.debugMode = True
self.debugVideoPath = '/Users/071cht/Desktop/Lab/jaabagui/testt.mjpeg.avi'
QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.installEventFilter(self)
self.setFocusPolicy(Qt.StrongFocus)
#add new slider
# self.positionSlider=QSlider(Qt.Horizontal)
# self.positionSlider.setGeometry (800,800,100,30)
# self.positionSlider.setRange(0, 0)
# self.positionSlider.sliderMoved.connect(self.setPosition)
#setup Video
#video player
self.mediaPlayer1 = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer2 = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer2.setNotifyInterval(10)
#self.mediaPlayer.metaDataChanged.connect(self.metaDataChanged)
self.mediaPlayer1.durationChanged.connect(self.durationChanged)
self.mediaPlayer1.positionChanged.connect(self.positionChanged)
self.mediaPlayer2.positionChanged.connect(self.positionChanged)
#self.mediaPlayer2.positionChanged.connect(self.paintEvent)
#visualizetion
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
#self.scene.setBackgroundBrush(Qt.black)
self.videoItem1 = QGraphicsVideoItem()
self.videoItem2 = Video()
self.scene.addItem(self.videoItem1)
self.scene.addItem(self.videoItem2)
self.mediaPlayer1.setVideoOutput(self.videoItem1)
self.mediaPlayer2.setVideoOutput(self.videoItem2)
#slider bar
self.ui.horizontalSlider.setRange(0, 0)
self.ui.horizontalSlider.sliderMoved.connect(self.setPosition)
# self.ui.horizontalSlider.sliderPressed.connect(self.sliderPressed)
#draw on video
self.flyCanvas = TargetView()
self.scene.addItem(self.flyCanvas)
#give reference to target view
self.flyCanvas.setWindowReference(self)
#lineEdit signals:
self.ui.lineEdit.returnPressed.connect(self.lineEditChanged)
#callbacks
self.ui.actionQuit.triggered.connect(self.quit)
self.ui.actionLoad_Project.triggered.connect(self.loadVideo)
self.ui.actionImport_Labels.triggered.connect(self.loadLabels)
#self.ui.buttonPlay.clicked[bool].connect(self.setToggleText)
self.ui.buttonPlay.clicked.connect(self.play)
self.ui.actionSave.triggered.connect(self.saveLabels)
## print self.ui.graphicsView.sizeHint()
#behavior Button
self.ui.buttonBehavior.clicked.connect(self.behaviorButtonClick)
self.ui.buttonNone.clicked.connect(self.noneButtonClick)
#initialization
self.loaded = False
self.videoFilename = None
self.frame_count = None
self.width = None
self.height = None
self.frame_trans = None
self.previous_frame = 0
self.current_frame = 0
self.behaviorButtonStart = False
self.noneButtonStart = False
self.currentFly = 1
#initialize flyInfo
#self.setCurrentFly(self.currentFly)
# register flyid changed callback
self.flyCanvas.onCurrentFlyIdChanged(self.currentFlyIdChangedCallback)
self.flyCanvas.setCurrentFlyId(self.currentFly)
# when double click on video, change fly id in target view
self.videoItem2.onDoubleClick(self.flyCanvas.setCurrentFlyIdByXY)
########################
# DEBUG PART HERE!!!!! #
########################
if (self.debugMode):
self.debugLoadVideo()
# add label UI related when load video
def showEvent(self, evt):
super(jaabaGUI, self).showEvent(evt)
##### HERE THE WINDOW IS LOADED!!!!!!!!
# self.loadLabelUI()
def loadLabelUI(self):
#labels
self.labelScene = QGraphicsScene()
self.ui.graphLabels.setScene(self.labelScene)
# the size is only accurate after the window fully displayed
labelUIWidth = self.ui.graphLabels.width()
labelUIHeight = self.ui.graphLabels.height() - 1
self.labelScene.setSceneRect(0, 0, labelUIWidth, labelUIHeight)
self.labelUI = LabelUI()
# visiableWidth = 850
# height = 30
# visiableFrameNum = 850
self.labelUI.setWidthPerFrame(850.0 / 850.0)
# print '850/500',850.0/850.0b
# print 'length_perframe is ', self.labelUI.widthPerFrame
# 850 is the original length of graphLabel
total_length = self.labelUI.widthPerFrame * self.frame_count
self.labelUI.setVisiableSize(total_length, 30)
# set start position
self.labelUI.setPos(labelUIWidth / 2, 0)
print 'frame_count is ', self.frame_count
print 'total length is', total_length
self.labelScene.addItem(self.labelUI)
# middle line ui
self.labelUIMiddleLine = LabelUIMiddleLine()
self.labelScene.addItem(self.labelUIMiddleLine)
self.labelUIMiddleLine.setPos(labelUIWidth / 2, 0)
# self.labelUI.setPos(QPointF(-100,0))
self.writeLog('Label UI loaded')
def eventFilter(self, obj, event):
if (event.type() == PyQt5.QtCore.QEvent.KeyPress):
# http://qt-project.org/doc/qt-4.8/qt.html#Key-enum
key = event.key()
if (key == Qt.Key_Up):
curr_frame = int(float(self.ui.lineEdit.text()))
curr_frame = curr_frame - 30
media_position = int(round(curr_frame * self.frame_trans))
# print curr_frame, media_position
self.mediaPlayer1.setPosition(media_position)
self.mediaPlayer2.setPosition(media_position)
# print 'down -30'
elif (key == Qt.Key_Right):
curr_frame = int(float(self.ui.lineEdit.text()))
# print 'right +1'
# print curr_frame
curr_frame = curr_frame + 1
media_position = int(round(curr_frame * self.frame_trans))
# print 'curr_frame',curr_frame
# print 'frame_trans',self.frame_trans
# print ' curr_frame*self.frame_trans',curr_frame*self.frame_trans
# print 'media_position',media_position
# print curr_frame, media_position
self.mediaPlayer1.setPosition(media_position)
self.mediaPlayer2.setPosition(media_position)
# self.mediaPlayerPositionChanged(media_position)
elif (key == Qt.Key_Left):
curr_frame = int(float(self.ui.lineEdit.text()))
curr_frame = curr_frame - 1
media_position = int(round(curr_frame * self.frame_trans))
self.mediaPlayer1.setPosition(media_position)
self.mediaPlayer2.setPosition(media_position)
# print 'left -1'
elif (key == Qt.Key_Down):
curr_frame = int(float(self.ui.lineEdit.text()))
curr_frame = curr_frame + 30
media_position = int(round(curr_frame * self.frame_trans))
self.mediaPlayer1.setPosition(media_position)
self.mediaPlayer2.setPosition(media_position)
# print 'up +30'
return True
return False
# ###actions starts from here###
def quit(self):
QApplication.quit()
def loadVideo(self):
# print QMediaPlayer.supportedMimeTypes()
self.writeLog("Loading video...")
self.videoFilename = QFileDialog.getOpenFileName(
self, 'Open File', '.')[0]
if not self.videoFilename:
self.writeLog("User cancelled - no video loaded")
return
else:
cap = cv2.VideoCapture(self.videoFilename)
self.frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
self.width = cap.get(3)
self.height = cap.get(4)
self.mediaPlayer2.setMedia(
QMediaContent(QUrl.fromLocalFile(self.videoFilename)))
self.mediaPlayer1.setMedia(
QMediaContent(QUrl.fromLocalFile(self.videoFilename)))
self.ui.buttonPlay.setEnabled(True)
# self.mediaPlayer2.setVideoOutput(self.videoItem2)
# self.mediaPlayer1.setVideoOutput(self.videoItem1)
# size= self.videoItem2.nativeSize()
# # print size
## print self.mediaPlayer.duration()
## print self.mediaPlayer.metaData()
self.writeLog("Video loaded!")
# init label related ui
self.loadLabelUI()
def debugLoadVideo(self):
self.videoFilename = self.debugVideoPath
cap = cv2.VideoCapture(self.videoFilename)
self.frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
self.width = cap.get(3)
self.height = cap.get(4)
self.mediaPlayer2.setMedia(
QMediaContent(QUrl.fromLocalFile(self.videoFilename)))
self.mediaPlayer1.setMedia(
QMediaContent(QUrl.fromLocalFile(self.videoFilename)))
self.ui.buttonPlay.setEnabled(True)
self.writeLog("Video loaded!")
QTimer.singleShot(1000, self.loadLabelUI)
def play(self):
self.videoItem1.setAspectRatioMode(0)
self.videoItem2.setAspectRatioMode(0)
self.scene.setSceneRect(0, 0, self.ui.graphicsView.width(),
self.ui.graphicsView.height())
self.videoItem1.setSize(
QSizeF(self.ui.graphicsView.width() / 2,
self.ui.graphicsView.height()))
self.videoItem2.setSize(
QSizeF(self.ui.graphicsView.width() / 2,
self.ui.graphicsView.height()))
self.videoItem1.setPos(QPointF(0, 0))
self.videoItem2.setPos(QPointF(self.ui.graphicsView.width() / 2, 0))
self.flyCanvas.setPos(QPointF(self.ui.graphicsView.width() / 2, 0))
# custom function setXYScale
self.videoItem2.setXYScale(self.width, self.height,
self.ui.graphicsView.width() / 2,
self.ui.graphicsView.height())
self.flyCanvas.setXYScale(self.width, self.height,
self.ui.graphicsView.width() / 2,
self.ui.graphicsView.height())
if self.mediaPlayer1.state() == QMediaPlayer.PlayingState:
self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(
PyQt5.QtWidgets.QStyle.SP_MediaPlay))
self.ui.buttonPlay.setText("Play")
self.mediaPlayer1.pause()
self.writeLog("Video paused")
else:
self.ui.buttonPlay.setIcon(self.ui.style().standardIcon(
PyQt5.QtWidgets.QStyle.SP_MediaPause))
self.ui.buttonPlay.setText("Stop")
self.mediaPlayer1.play()
self.writeLog("Playing video")
if self.mediaPlayer2.state() == QMediaPlayer.PlayingState:
self.mediaPlayer2.pause()
else:
self.mediaPlayer2.play()
def loadLabels(self):
self.writeLog("Loading labels from file...")
self.labelFilename = QFileDialog.getOpenFileName(
self, 'Open File', '.')[0]
self.labelUI.labelData = pickle.load(open(self.labelFilename, "rb"))
self.writeLog("Label loaded from file:" + self.labelFilename)
def saveLabels(self):
# Now it can only save to current file. Will add an poput window to choose path later
pickle.dump(self.labelUI.labelData, open("newLabels.p", "wb"))
def setPosition(self, position):
self.mediaPlayer1.setPosition(position)
self.mediaPlayer2.setPosition(position)
# when position of media changed, set slider and text box accordingly.
def positionChanged(self, position):
#test change labelui position
# self.labelUI.startLabel();
# self.labelUI.update()
previous_frame = self.previous_frame
curr_frame = int(round(position / self.frame_trans))
self.current_frame = curr_frame
frame_change = previous_frame - curr_frame
move_width = frame_change * self.labelUI.widthPerFrame
self.previous_frame = curr_frame
self.labelUI.moveBy(move_width, 0)
self.labelUI.setCurrentFrame(curr_frame)
# enforce labelUI paint once
self.labelUI.update()
# self.labelUI.setPos(self.labelUI.mapToParent(1,0));
# self.labelUI.update()
# # print 'triggered position'
# # print position
# # print 'cur position'
# # print self.mediaPlayer2.position()
self.updateLineEdit(position)
self.updateSliderAndGraph(position)
# self.ui.horizontalSlider.setValue(position)
# if isinstance(self.frame_trans,float):
# # # print type(position),position
# # # print type(self.frame_trans),self.frame_trans
# # # print position/self.frame_trans
# self.ui.lineEdit.setText(str(int(round(position/self.frame_trans))))
# self.flyCanvas.getFrame(int(round(position/self.frame_trans)))
# self.flyCanvas.isManualCalled = True;
# self.flyCanvas.update()
# self.writeLog(str(position))
# # self.updateMediaControlUI(position)
# # self.flyCanvas.update()
def updateSliderAndGraph(self, position):
self.ui.horizontalSlider.setValue(position)
if isinstance(self.frame_trans, float):
self.flyCanvas.getFrame(int(round(position / self.frame_trans)))
self.flyCanvas.isManualCalled = True
self.flyCanvas.update()
#self.writeLog(str(position))
def updateLineEdit(self, position):
# # print self.width
# # print self.height
if isinstance(self.frame_trans, float):
# # print type(position),position
# # print type(self.frame_trans),self.frame_trans
# # print position/self.frame_trans
self.ui.lineEdit.setText(
str(int(round(position / self.frame_trans))))
def durationChanged(self, duration):
self.ui.horizontalSlider.setRange(0, duration)
self.frame_trans = self.mediaPlayer1.duration() / self.frame_count
## print self.frame_trans
#def eventFilter(self,source,event):
#if (event.type()==PyQt5.QtCore.QEvent.MousePress and source is self.videoItem2):
# pos=event.pos()
# # print('mouse position: (%d,%d)' % (pos.x(),pos.y()))
# return PyQt5.QtGui.QWidget.eventFilter(self, source, event)
def writeLog(self, text):
self.ui.log.setText(text)
# def eventFilter (self.ui.lineEdit,event):
# if event.type()==PyQt5.QtCore.QEvent
def lineEditChanged(self):
#set position of media
curr_frame = int(float(self.ui.lineEdit.text()))
media_position = int(round(curr_frame * self.frame_trans))
self.mediaPlayer1.setPosition(media_position)
self.mediaPlayer2.setPosition(media_position)
# print 'setPosition'
# print media_position
# print 'after set'
# print self.mediaPlayer2.position()
# self.updateSliderAndGraph(media_position)
def behaviorButtonClick(self):
# flip flag
self.behaviorButtonStart = not self.behaviorButtonStart
# check click to start or stop
if (self.behaviorButtonStart):
# start labeling
self.labelUI.startLabel(self.ui.comboBox.currentIndex(), '',
self.current_frame)
self.writeLog('start labeling')
else:
# stop lableing
self.labelUI.stopLabel()
self.writeLog('stop labeling')
def noneButtonClick(self):
# flip flag
self.noneButtonStart = not self.noneButtonStart
# check click to start or stop
if (self.noneButtonStart):
# start labeling
self.labelUI.startLabel(self.ui.comboBox.currentIndex(), '_none',
self.current_frame)
self.writeLog('start labeling')
else:
# stop lableing
self.labelUI.stopLabel()
self.writeLog('stop labeling')
# set CurrentFly when fly changed!
def setCurrentFly(self, fly):
self.currentFly = fly
self.ui.flyInfo.setPlainText('FlyID:' + str(self.currentFly))
self.flyCanvas.currentFly = fly
def currentFlyIdChangedCallback(self, fly):
print 'callback!!!!!'
self.currentFly = fly
self.ui.flyInfo.setPlainText('FlyID:' + str(self.currentFly))
