class coppin(QWidget):
def __init__(self):
QWidget.__init__(self)
p = self.palette()
p.setColor(QPalette.Window, Qt.black)
self.setPalette(p)
self.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
self.center()
self.init_ui()
self.play()
def center(self): #for load ui at center of screen
frameGm = self.frameGeometry()
screen = PyQt5.QtWidgets.QApplication.desktop().screenNumber(
PyQt5.QtWidgets.QApplication.desktop().cursor().pos())
centerPoint = PyQt5.QtWidgets.QApplication.desktop().screenGeometry(
screen).center()
frameGm.moveCenter(centerPoint)
self.move(frameGm.topLeft())
def init_ui(self):
#create media player object
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videowidget = QVideoWidget()
self.mediaPlayer.setVideoOutput(videowidget)
vboxLayout = QVBoxLayout()
vboxLayout.addWidget(videowidget)
def play(self):
self.mediaPlayer.setMedia(
QMediaContent(
QUrl.fromLocalFile(os.path.join(os.getcwd(), "warning3.mp4"))))
self.mediaPlayer.play()
class VideoPlayer(QVideoWidget):
def __init__(self):
super(VideoPlayer, self).__init__()
self._player = QMediaPlayer()
self._playlist = QMediaPlaylist()
self._stopped = True
# プレイリストに動画を追加
def addMedia(self, media_file):
media_content = QMediaContent(QUrl.fromLocalFile(media_file))
self._playlist.addMedia(media_content)
# クリックでポーズ・再生の切り替え
def mousePressEvent(self, event):
if self._stopped:
self.play()
else:
self._player.pause()
self._stopped = True
# ダブルクリックで動画を読み込み，再生
def mouseDoubleClickEvent(self, event):
self._player.setVideoOutput(self)
self._player.setPlaylist(self._playlist)
self.play()
def play(self):
self._player.play()
self._stopped = False
class PlayerDialog(QDialog):
def __init__(self, video, dimensions, parent=None):
QDialog.__init__(self,
parent=parent,
flags=QtCore.Qt.WindowSystemMenuHint
| QtCore.Qt.WindowTitleHint
| QtCore.Qt.WindowCloseButtonHint)
uic.loadUi('resources/videoplay.ui', self)
self.videoWidget = QVideoWidget()
self.stageLayout.addWidget(self.videoWidget)
self.stage.setMinimumSize(QtCore.QSize(dimensions[0], dimensions[1]))
self.playbtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.seekslider.mousePressEvent = self.__direct_slider_click
self.seekslider.sliderMoved.connect(self.set_position)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.__media_state_changed)
self.mediaPlayer.positionChanged.connect(self.__position_changed)
self.mediaPlayer.durationChanged.connect(self.__duration_changed)
self.mediaPlayer.error.connect(self.handle_error)
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(video)))
def __media_state_changed(self, state):
if state == QMediaPlayer.PlayingState:
self.playbtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playbtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
if state == QMediaPlayer.StoppedState:
self.play()
def __direct_slider_click(self, event):
if event.button() == QtCore.Qt.LeftButton:
calc_value = self.seekslider.minimum() + (
(self.seekslider.maximum() - self.seekslider.minimum()) *
event.x()) / self.seekslider.width()
self.seekslider.setValue(calc_value)
self.set_position(calc_value)
event.accept()
QSlider.mousePressEvent(self.seekslider, event)
def __position_changed(self, position):
self.seekslider.setValue(position)
def __duration_changed(self, duration):
self.seekslider.setRange(0, duration)
self.play()
def handle_error(self):
logger.error(self.mediaPlayer.errorString())
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def set_position(self, position):
self.mediaPlayer.setPosition(position)
class ExampleApp(QtWidgets.QMainWindow, untitled.Ui_MainWindow):
def __init__(self): # Main Processor ui class...
super().__init__()
self.setupUi(self)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.positionChanged.connect(self.position_changed)
self.mediaPlayer.durationChanged.connect(self.duration_changed)
self.mediaPlayer.stateChanged.connect(self.mediastate_changed)
self.horizontalSlider.sliderMoved.connect(self.set_position)
self.horizontalSlider_2.sliderMoved.connect(self.set_volume)
self.mediaPlayer.setVideoOutput(self.widget)
self.pushButton.clicked.connect(self.open_file)
self.pushButton_2.clicked.connect(self.play_video)
self.pushButton_2.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
self.horizontalSlider.setSliderPosition(0)
self.mediaPlayer.setVolume(50)
def open_file(self):
filename, _ = QFileDialog.getOpenFileName(self, "Open Video")
if filename != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(filename)))
self.pushButton_2.setEnabled(True)
def play_video(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediastate_changed(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.pushButton_2.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.pushButton_2.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def position_changed(self, position):
self.horizontalSlider.setValue(position)
def duration_changed(self, duration):
self.horizontalSlider.setRange(0, duration)
def set_position(self, position):
self.mediaPlayer.setPosition(position)
def set_volume(self, position):
value = self.horizontalSlider_2.value()
self.mediaPlayer.setVolume(value)
self.statusBar.showMessage("Громкость " + str(value) + " %")
class VideoPlayer(QVideoWidget):
def __init__(self):
super(VideoPlayer, self).__init__()
self._player = QMediaPlayer()
self._playlist = QMediaPlaylist()
self._stopped = True
# プレイリストに動画を追加
def addMedia(self, media_file):
media_content = QMediaContent(QUrl.fromLocalFile(media_file))
self._playlist.addMedia(media_content)
# クリックでポーズ・再生の切り替え
def mousePressEvent(self, event):
if self._stopped:
self.play()
else:
self._player.pause()
self._stopped = True
# ダブルクリックで動画を読み込み，再生
def mouseDoubleClickEvent(self, event):
self._player.setVideoOutput(self)
self._player.setPlaylist(self._playlist)
self.play()
def play(self):
self._player.play()
self._stopped = False
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.playButton = QPushButton()
self.playButton.setEnabled(True)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
videoWidget = QVideoWidget()
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
self.setLayout(layout)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
def play(self):
self.mediaPlayer = QMediaPlayer.setMedia(
QUrl("rtsp://xxx.xxx.xx.xx:554/live.sdp"))
videoWidget = QVideoWidget()
self.mediaPlayer.setVidioOutput(videoWidget)
#self.mediaPlayer.play
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.video_item = QGraphicsVideoItem()
self.scene = QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(QColor(0, 0, 0, 255)))
self.graphics_view = QGraphicsView(self.scene)
self.graphics_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setFrameStyle(0)
self.graphics_view.setStyleSheet(
"QGraphicsView {background: transparent; border: 3px; outline: none;}"
)
self.scene.addItem(self.video_item)
layout = QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.graphics_view)
self.media_player.setVideoOutput(self.video_item)
def play(self, url):
self.media_player.setMedia(QMediaContent(QUrl.fromLocalFile(url)))
self.media_player.play()
class VideoWindow(QVideoWidget):
def __init__(self, filename):
super().__init__()
if not path.exists(filename):
print("\nFile '{}' doesn't exist!".format(filename))
quit()
self.width = SCREEN_WIDTH
self.filename = filename
self.video = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.video.setVideoOutput(self) #setting the video output
self.video.mediaStatusChanged.connect(
self.end_of_video) #setting a signal of the video end
self.video.setMedia(QMediaContent(
QUrl.fromLocalFile(filename))) #openning the file
self.video.play()
self.video.pause()
def start(self):
info_message(
QMessageBox.Information, 'Instruction',
'In this part of the experiment, you will need to watch a video from the beginning till the end.\n\nNote: If you want to exit the experiment before the end, click the "Exit the experiment" buttom at the bottom of the screen.'
)
self.video.play()
def exit_confirmation(self): #asking confirmation to stop the video
self.video.pause()
returnValue = exit_question_message()
if returnValue == QMessageBox.Yes:
info_message(QMessageBox.Information, 'Experiment termination',
'The experiment has been stopped by the user')
quit()
else:
self.video.play()
def end_of_video(self, status): #responding to the end signal
if status == self.video.EndOfMedia:
info_message(QMessageBox.Information, 'The end of the video',
'The video has finished')
if self.filename == FILENAME1:
a = self.ask_A()
if a != '3':
info_message(
QMessageBox.Information, 'The end of the experiment',
'This is the end of the experiment.\nThank you for your participation.'
)
quit()
experiment.next_in_scenario()
def ask_A(self):
'''ask how many A'''
while True: #Doesn't allow to close the window
items = ('0', '1', '2', '3', '4', '5')
item, okPressed = QInputDialog().getItem(
self, 'Question',
'How many letters A have you seen?\nThe number of A:', items,
0, False)
if okPressed and item:
return item
class Player(QDialog):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# self.show()
self.ui.btn_play.clicked.connect(self.playvideo) #включить видео
self.ui.btn_stop.clicked.connect(self.stopvideo) #остановить видео
self.ui.btn_pause.clicked.connect(self.pausevideo) #пауза
self.ui.btn_back.clicked.connect(self.hidewindow) #скрыть окно плеера
self.ui.verticalSlider.valueChanged.connect(self.setvolume) #громкость
# self.ui.horizontalSlider.valueChanged.connect(self.settimevideo) #перемотка - починить функцию
self.ui.listWidget.addItems(listdir("records")) #генерация списка файлов в папке records
self.ui.listWidget.itemClicked.connect(self.playthis) #выбор видео
self.player = QMediaPlayer()
self.player.positionChanged.connect(self.setvideoonslider)#автодвижение ползунка
self.video = QVideoWidget(self.ui.label)
self.video.resize(621, 451)
self.video.move(0, 0)
self.player.setVideoOutput(self.video)
self.video.show()
self.ui.label.customContextMenuRequested.connect(self.testfun) #ПРАВАЯ КНОПКА МЫШИ
def testfun(self):
print("Тест успешен")
def playvideo(self):
self.player.play()
self.ui.horizontalSlider.setMaximum(self.player.duration())
self.ui.horizontalSlider.setPageStep(self.player.duration() / 10)
def stopvideo(self):
self.player.stop()
def pausevideo(self):
self.player.pause()
def hidewindow(self):
self.hide()
def setvolume(self):
self.player.setVolume(self.ui.verticalSlider.value())
def settimevideo(self):
self.player.setPosition(self.ui.horizontalSlider.value())
def playthis(self):
self.player.setMedia(QMediaContent(QUrl.fromLocalFile("records/" + str(self.ui.listWidget.currentItem().text()))))
def setvideoonslider(self):
self.ui.horizontalSlider.setValue(self.player.position())
self.ui.lbl_time.setText(str(int(self.player.position() / 1000)) + "/" + str(int(self.player.duration() / 1000)))
def test(self):
print("Тест пройден")
class PlayVideo(DisplayEvent):
def __init__(self, frame, settings):
super().__init__(frame, settings)
self.url = QUrl(settings.get("url"))
self.start_time = settings.get("start", 0) * 1000
self.duration = settings.get("duration")
self.loop = settings.get("loop", True)
self.volume = settings.get("volume", 100)
self.playback_rate = settings.get("playbackRate", 1.0)
def do_tick(self):
if self.player:
self.logging.info("position: %s/%s status: %s error: %s" % (
self.player.position(),
self.player.duration(),
self.player.mediaStatus(),
self.player.errorString(),
))
if self.player.errorString():
self.logging.error(self.player.errorString())
self.cancel()
def do_initialize(self):
super().do_initialize()
self.video = QVideoWidget(self.widget)
self.add_widget(self.video)
self.video.show()
self.media = QMediaContent(self.url)
self.playlist = QMediaPlaylist(self.video)
self.playlist.addMedia(self.media)
self.playlist.setPlaybackMode(
QMediaPlaylist.Loop if self.loop else QMediaPlaylist.Sequential)
self.player = QMediaPlayer(self.widget)
self.player.setVideoOutput(self.video)
self.player.setVolume(self.volume)
self.player.setPlaybackRate(self.playback_rate)
def do_run(self):
super().do_run()
self.player.setPlaylist(self.playlist)
self.player.setPosition(self.start_time)
self.player.play()
if self.player.errorString():
self.logging.error(self.player.errorString())
self.cancel()
def do_stop(self):
super().do_stop()
self.player.stop()
def do_reset(self):
self.player = None
self.video = None
class MyWin(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = Ui_VideoPlayer()
self.ui.setupUi(self)
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.media_player_widget = QVideoWidget(self.ui.mid_frame)
self.ui.mid_frame_layout.addWidget(self.media_player_widget)
self.media_player.setVideoOutput(self.media_player_widget)
self.media_player.error.connect(self.handleError)
# fileName="E:/Dropbox/Hobby/PRG/PyWork/FGet/view/qt_ui/files/1.mp4"
# self.media_player.setMedia(QMediaContent(QUrl.fromLocalFile(fileName)))
# fileName="E:/exchange/DiskD/kl/1/road_to_abbi_big-1080.mp4.Epidemz.net_Triksa.com.mp4"
# self.media_player.setMedia(QMediaContent(QUrl.fromLocalFile(fileName)))
self.ui.bn_go.clicked.connect(self.go)
self.media_player.bufferStatusChanged.connect(self.buf)
self.media_player.mediaStatusChanged.connect(self.med)
# url='http://tubedupe.com/get_file/1/693b07616d5019e3e266e772676e3048/56000/56102/56102.mp4'
url = 'http://tubedupe.com/get_file/1/4b274e3f4027b13bf6d6ae5601dd7a09/50000/50768/50768.mp4'
url = 'http://www.mypornovideo.net/video_file/2015/2/830/grudastaja_blondinka_ebetsja_s_kuchejj_muzhikov.flv'
url = "http://im.50f9bc00.493dea4.cdn2b.movies.mxn.com/0/399/399060/NOWATERMARK_IPOD.mp4?s=1423689551&e=1423696751&ri=1227&rs=44&h=d0a58a04acc858983a202b5e8dea575a"
self.media_player.setMedia(QMediaContent(QUrl(url)))
self.media_player.play()
self.media_player.setMuted(True)
print(self.media_player.duration())
print('Done')
def handleError(self):
print('Error: ' + self.media_player.errorString())
def buf(self, percent):
print(percent, '%')
def med(self, media):
print(media)
def go(self):
dur = self.media_player.duration()
pos = self.media_player.position()
print(dur // 1000, pos // 1000)
print(self.media_player.bufferStatus())
# self.hide()
self.media_player.stop()
class CamConfig(QWidget,_camconfig.Mixin):
def __init__(self):
super(CamConfig, self).__init__()
self.setWindowTitle("Configurações de Câmera")
self.setWindowIcon(QIcon('./gui/res/icon_device.png'))
self.ipcamservices = IpCamServices()
self.UI()
self.populateCameras()
def UI(self):
layout = QHBoxLayout()
self.setLayout(layout)
self.ipcam = QUrl('')
self.mp = QMediaPlayer()
self.vw = QVideoWidget()
self.media = QMediaContent(QNetworkRequest(self.ipcam))
self.mp.setMedia(self.media)
self.mp.setVideoOutput(self.vw)
#self.mp.play()
self.vw.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding)
vbox = QVBoxLayout()
vbox.addWidget(self.vw)
layout.addLayout(vbox)
#self.vw.show()
form = QFormLayout()
self.lstCameras = QListWidget()
layout.addLayout(form)
self.edtIP = QLineEdit()
self.btnConnect = QPushButton('Conectar')
self.btnSelectVideo = QPushButton('Selecionar vídeo')
self.btnSave = QPushButton('Salvar modificações')
self.btnConnect.clicked.connect(self.btnConnect_onclick)
self.btnSave.clicked.connect(self.btnSave_onclick)
self.btnSelectVideo.clicked.connect(self.btnSelectVideo_onclick)
form.addRow(self.lstCameras)
layout = QHBoxLayout()
layout.addWidget(self.edtIP)
layout.addWidget(self.btnConnect)
form.addRow(layout)
layout = QHBoxLayout()
layout.addWidget(self.btnSelectVideo)
layout.addWidget(self.btnSave)
form.addRow(layout)
self.lstCameras.currentRowChanged.connect(self.lstCameras_changed)
def initUI(self):
self.resize(1920, 1200)
self.main_widget = QWidget() # 创建窗口主部件
self.main_widget.setObjectName("main_widget")
self.main_layout = QGridLayout() # 创建主部件的网格布局
self.main_widget.setLayout(self.main_layout) #
self.setCentralWidget(self.main_widget)
self.main_widget.setStyleSheet('''
#main_widget{
border-image:url(./Ui_images/blackB.jpg);
border-radius:30px
}
}
''')
self.gif = QMovie("./Ui_images/2.gif")
self.scorelabel = QLabel(self.main_widget)
self.scorelabel.setGeometry(800, 700, 140, 70)
self.scorelabel.setMovie(self.gif)
self.gif.start()
self.videoframe = QLabel(self.main_widget)
self.videoframe.setGeometry(1000, 200, 800, 448)
self.scoreframe = QLabel(self.main_widget)
self.scoreframe.setGeometry(965, 712, 150, 50)
self.scoreframe.setAlignment(Qt.AlignVCenter)
self.th = Thread(self.video_csv)
self.th.changePixmap.connect(self.setImage)
self.th.score.connect(self.setText)
#self.th.finished.connect(self.save_ranking)
self.th.start()
time.sleep(2)
vw1 = QVideoWidget(self.main_widget)
vw1.setGeometry(100, 200, 800, 448)
player = QMediaPlayer(self.main_widget)
player.setVideoOutput(vw1)
player.setMedia(QMediaContent(QUrl("file:///" + self.video_path)))
player.play()
# self.setWindowOpacity(0.9) # 设置窗口透明度
# self.setAttribute(Qt.WA_TranslucentBackground) # 设置窗口背景透明
#self.setWindowFlag(Qt.FramelessWindowHint) # 隐藏边框
self.show()
class Player(QGraphicsVideoItem):
def __init__(self, parent=None):
super().__init__()
self.parent = parent
self.player = QMediaPlayer()
self.player.setVideoOutput(self)
def playerPlayOrOpen(self, arg=None):
if type(arg) == list and len(arg) > 1:
content = QMediaContent(QUrl.fromLocalFile(arg[1]))
self.player.setMedia(content)
self.play()
def addVideo(self, video):
content = QMediaContent(QUrl.fromLocalFile(video))
self.player.setMedia(content)
self.play()
def sliderChanged(self, pos):
self.player.setPosition(pos)
def mouseDoubleClickEvent(self, event):
if not self.parent.isFullScreen():
self.parent.showFullScreen()
else:
self.parent.showNormal()
def play(self):
self.player.play()
def stop(self):
self.player.stop()
def pause(self):
self.player.pause()
def setMuted(self, mute):
self.player.setMuted(mute)
def mutedState(self):
if self.player.isMuted():
self.setMuted(False)
else:
self.setMuted(True)
def isMuted(self):
return self.player.isMuted()
def setVolume(self, value):
self.player.setVolume(value)
def volume(self):
return self.player.volume()
class WelcomeWindow(QMainWindow, Ui_WelcomeWindow):
def __init__(self, welcomeVid):
super(self.__class__, self).__init__()
self.setupUi(self)
self.player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.pList = QMediaPlaylist()
media = QUrl("file://" + welcomeVid)
self.pList.addMedia(QMediaContent(media))
self.player.setPlaylist(self.pList)
self.pList.setPlaybackMode(QMediaPlaylist.CurrentItemInLoop)
self.player.setVideoOutput(self.welcomeVideo)
class Player(QGraphicsVideoItem):
def __init__(self, parent=None):
super().__init__()
self.parent = parent
self.player = QMediaPlayer()
self.player.setVideoOutput(self)
def playerPlayOrOpen(self, arg=None):
if type(arg) == list and len(arg) > 1:
content = QMediaContent(QUrl.fromLocalFile(arg[1]))
self.player.setMedia(content)
self.play()
def addVideo(self, video):
content = QMediaContent(QUrl.fromLocalFile(video))
self.player.setMedia(content)
self.play()
def sliderChanged(self, pos):
self.player.setPosition(pos)
def mouseDoubleClickEvent(self, event):
if not self.parent.isFullScreen():
self.parent.showFullScreen()
else:
self.parent.showNormal()
def play(self):
self.player.play()
def stop(self):
self.player.stop()
def pause(self):
self.player.pause()
def setMuted(self, mute):
self.player.setMuted(mute)
def mutedState(self):
if self.player.isMuted():
self.setMuted(False)
else:
self.setMuted(True)
def isMuted(self):
return self.player.isMuted()
def setVolume(self, value):
self.player.setVolume(value)
def volume(self):
return self.player.volume()
class VideoPlayerWidget(QWidget):
def __init__(self, parent=None):
super(VideoPlayerWidget, self).__init__(parent)
self.scene = QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(QColor(0, 0, 0, 255)))
self.graphics_view = QGraphicsView(self.scene)
self.graphics_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setFrameStyle(0)
self.graphics_view.setStyleSheet("QGraphicsView {background: transparent; border: 3px; outline: none;}")
self.video_item = QGraphicsVideoItem()
self.scene.addItem(self.video_item)
self.layout = QVBoxLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.graphics_view)
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.media_player.setVideoOutput(self.video_item)
self.video_need_replay = False
self.video_seek_durcation = 3000 # in milliseconds
def resizeEvent(self, event):
self.video_item.setSize(QSizeF(event.size().width(), event.size().height()))
QWidget.resizeEvent(self, event)
def play(self, url):
self.media_player.setMedia(QMediaContent(QUrl.fromLocalFile(url)))
self.media_player.play()
def seek_forward(self):
video_position = self.media_player.position()
self.media_player.setPosition(video_position + self.video_seek_durcation)
def seek_backward(self):
video_position = self.media_player.position()
self.media_player.setPosition(max(video_position - self.video_seek_durcation, 0))
def keyPressEvent(self, event):
if event.key() == Qt.Key_Space:
if self.media_player.state() == QMediaPlayer.PlayingState:
self.media_player.pause()
self.video_need_replay = False
else:
self.media_player.play()
self.video_need_replay = True
elif event.key() == Qt.Key_H:
self.seek_backward()
elif event.key() == Qt.Key_L:
self.seek_forward()
class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'Main'
self.left = 10
self.top = 10
self.width = 640
self.height = 480
self.setWindowTitle(self.title)
# self.setGeometry(self.left, self.top, self.width, self.height)
# Create video widget
self.videoWidget = QVideoWidget()
self.videoWidget.aspectRatioMode = Qt.KeepAspectRatio
self.videoWidget.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Preferred)
self.videoWidget.setMinimumSize(320, 320)
# Create Media player
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self.videoWidget)
# self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(os.path.abspath('sample2.mov'))))
# Create media player bridge
self.mediaPlayerBridge = MediaPlayerBridge(self.mediaPlayer)
# Create Web View
self.webView = QtWebEngineWidgets.QWebEngineView()
self.webView.setContextMenuPolicy(
Qt.PreventContextMenu) # TODO: test NoContextMenu
# self.webView.setWindowFlags(Qt.FramelessWindowHint)
# self.webView.setAttribute(Qt.WA_TranslucentBackground, True)
self.page = WebRTCPageView()
self.page.setBackgroundColor(Qt.transparent)
self.page.objects = {"mediaPlayerBridge": self.mediaPlayerBridge}
self.page.profile().clearHttpCache()
self.webView.setPage(self.page)
# Create layout
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
layout.addWidget(self.videoWidget)
layout.addWidget(self.webView)
self.setLayout(layout)
self.resize(640, 800)
self.show()
self.mediaPlayer.play()
class Video:
def __init__(self, mainWindow):
self.mainWindow = mainWindow
self.fileName = ''
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(
self.mainWindow.positionChanged)
self.mediaPlayer.durationChanged.connect(
self.mainWindow.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self.mainWindow,
"Open Movie",
QDir.homePath())
if fileName != '':
self.fileName = fileName
def setMediaPlayer(self, fileName):
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(fileName)))
self.mainWindow.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mainWindow.playButton.setIcon(
self.mainWindow.style().standardIcon(QStyle.SP_MediaPause))
else:
self.mainWindow.playButton.setIcon(
self.mainWindow.style().standardIcon(QStyle.SP_MediaPlay))
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.mainWindow.playButton.setEnabled(False)
self.mainWindow.errorLabel.setText("Error: " +
self.mediaPlayer.errorString())
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
ui = uic.loadUi('window_principale.ui', self) # Load the .ui file
label = QLabel(self)
pixmap = QPixmap('arblade.png')
label.setPixmap(pixmap)
url = QUrl("rtsp://192.168.8.187:1935/live/myStream")
player = QMediaPlayer(self, QMediaPlayer.VideoSurface)
player.setMedia(QMediaContent(url))
videoWidget = QVideoWidget(self)
player.setVideoOutput(videoWidget)
player.play()
self.show() # Show the GUI
class VideoPlayer(QVideoWidget):
onVideoStop = FuncDescriptor()
onVideoStart = FuncDescriptor()
onVideoPause = FuncDescriptor()
def __init__(self, parent: QWidget):
super().__init__(parent=parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self)
self.mediaPlayer.stateChanged.connect(self.onStateChanged)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self._video_path = None
@property
def video_path(self):
return self._video_path
@video_path.setter
def video_path(self, value):
log.debug(" _video_path set to {}".format(value))
self._video_path = value
self.q_url = QUrl.fromLocalFile(self._video_path)
self.mediaPlayer.setMedia(QMediaContent(self.q_url))
def showEvent(self, event: QtGui.QShowEvent):
super().showEvent(event)
exp_logger.info(f"Playing video: {self.video_path}")
self.mediaPlayer.play()
def onStateChanged(self):
"""
0 - StoppedState
1 - PlayingState
2 - PausedState
"""
state = self.mediaPlayer.state()
if state == 0:
self.onVideoStop()
elif state == 1:
self.onVideoStart()
elif state == 2:
self.onVideoPause()
else:
raise ValueError("Unknown state {}".format(state))
def closeEvent(self, QCloseEvent):
super().closeEvent(QCloseEvent)
log.debug("Close {}".format(self))
class Story(QMainWindow):
def __init__(self, language, side, username):
QMainWindow.__init__(self)
uic.loadUi("windows/Story.ui", self)
self.lang = language
self.username = username
self.side = side
self.reload_text()
#Declarando el reproductor y ajustándolo en la ventana
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
video_widget = QVideoWidget()
wid = QWidget(self)
self.setCentralWidget(wid)
layout = QVBoxLayout()
layout.addWidget(video_widget)
wid.setLayout(layout)
#Asignando la salida de video y el archivo a reproducir
self.media_player.setVideoOutput(video_widget)
self.media_player.setMedia(QMediaContent(QUrl.fromLocalFile(QFileInfo(self.video).absoluteFilePath())))
self.show()
def showEvent(self, event):
"""Play the story video when the window appears
This is an override method"""
self.media_player.play()
def hideEvent(self, event):
"""Stop the story video when the window close
This is an override method"""
self.media_player.stop()
def keyPressEvent(self, event):
"""Go to set ships window when the player press the space key
This is an override method"""
if event.key() == Qt.Key_Space:
from setShipsWindow import SetShips
self.ship = SetShips(self.lang, self.side, self.username)
self.ship.show()
self.close()
def reload_text(self):
"""Change the language of the window according to the chosen previously"""
self.language = LANGUAGE.get(self.lang)
self.setWindowTitle(self.language["story"])
self.video = self.language["video"]
class VideoPlayer:
def __init__(self):
self.video = QVideoWidget()
self.video.resize(300, 300)
self.video.move(0, 0)
self.player = QMediaPlayer()
self.player.setVideoOutput(self.video)
self.player.setMedia(
QMediaContent(
QUrl.fromLocalFile("/home/akhil/Videos/SoftwareTrial.mp4")))
def callback(self):
self.player.setPosition(
0) # to start at the beginning of the videowidget every time
self.video.show()
self.player.play()
def main():
app = QApplication(sys.argv)
# Create media player, read media URL from first command line argument
player = QMediaPlayer()
media = QMediaContent(QUrl(sys.argv[1]))
player.setMedia(media)
# Create and set video output widget
video = QVideoWidget()
player.setVideoOutput(video)
video.show()
player.play()
sys.exit(app.exec_())
class PlayerWindow(View):
def __init__(self):
super(PlayerWindow, self).__init__(ui_file="video_player_window.ui")
self.videoWidget = QVideoWidget(self.videoBackgroundWidget)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.videoBackgroundWidget.setStyleSheet(
"QWidget { background-color : black;}")
self.progressLabel = QLabel("00:00:00")
self.statusbar.addWidget(self.progressLabel)
self.messageLabel = QLabel("")
self.statusbar.addWidget(self.messageLabel)
self.mediaPositionSlider.setEnabled(False)
self.mediaPositionSlider.setStyleSheet("""
QSlider::handle:horizontal {
background: qlineargradient(x1:0, y1:0, x2:1, y2:1, stop:0 #b4b4b4, stop:1 #8f8f8f);
border: 0px solid #5c5c5c;
width: 16px;
margin: -2px -2px -2px -1px;
border-radius: 1px;
}
QSlider::sub-page:horizontal{
background:#3396DA;
}
""")
self.__init_icons()
self.update_icon(self.openButton, "open")
self.update_icon(self.playButton, "play")
self.update_icon(self.snapshotButton, "snapshot")
self.update_icon(self.startButton, "start")
self.update_icon(self.endButton, "end")
self.update_icon(self.autoSnapshotButton, "auto")
self.update_icon(self.imageStitchingButton, "stitching")
def __init_icons(self):
player = os.path.join("windows", "player")
self.add_icon("open.svg", player)
self.add_icon("play.svg", player)
self.add_icon("pause.svg", player)
self.add_icon("snapshot.svg", player)
self.add_icon("start.svg", player)
self.add_icon("end.svg", player)
self.add_icon("auto.svg", player)
self.add_icon("stitching.svg", player)
class VideoPlayer(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("PyQt5 Video Player")
self.mediaPlayer = QMediaPlayer()
videoWidget = QVideoWidget()
self.playButton = QPushButton()
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.openButton = QPushButton("Open Video")
self.openButton.clicked.connect(self.openFile)
widget = QWidget(self)
self.setCentralWidget(widget)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addWidget(self.openButton)
layout.addWidget(self.playButton)
widget.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
print("Done")
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie")
print(fileName)
if fileName != '':
print("Set")
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
def play(self):
print("Play")
self.mediaPlayer.play()
return
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
print("Do")
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
class PlayWindow(QWidget):
def open_file(self, file_name):
if len(file_name) > 0:
url = QUrl()
self.media_player.setMedia(QMediaContent(url.fromLocalFile(file_name)))
self.play_button.setEnabled(True)
self.show()
self.play()
def play(self):
if self.media_player.state() == QMediaPlayer.PlayingState:
self.media_player.pause()
else:
self.media_player.play()
def media_state_changed(self, state):
if state == QMediaPlayer.PlayingState:
self.play_button.setIcon(self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.play_button.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
def position_changed(self, position):
self.position_slider.setValue(position)
def duration_changed(self, duration):
self.position_slider.setRange(0, duration)
def set_position(self, position):
self.media_player.setPosition(position)
def handle_error(self):
self.play_button.setEnabled(False)
self.error_label.setText("Error: " + self.media_player.errorString())
def closeEvent(self, event):
event.ignore()
self.media_player.stop()
self.hide()
def __init__(self):
super(PlayWindow, self).__init__()
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.video_widget = QVideoWidget()
self.play_button = QPushButton()
self.play_button.setEnabled(False)
self.play_button.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.play_button.clicked.connect(self.play)
self.position_slider = QSlider(Qt.Horizontal)
self.position_slider.setRange(0, 0)
self.position_slider.sliderMoved.connect(self.set_position)
self.error_label = QLabel()
self.error_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
self.control_layout = QHBoxLayout()
self.control_layout.setContentsMargins(0, 0, 0, 0)
self.control_layout.addWidget(self.play_button)
self.control_layout.addWidget(self.position_slider)
self.layout = QVBoxLayout()
self.layout.addWidget(self.video_widget)
self.layout.addLayout(self.control_layout)
self.layout.addWidget(self.error_label)
self.setLayout(self.layout)
self.media_player.setVideoOutput(self.video_widget)
self.media_player.stateChanged.connect(self.media_state_changed)
self.media_player.positionChanged.connect(self.position_changed)
self.media_player.durationChanged.connect(self.duration_changed)
self.media_player.error.connect(self.handle_error)
self.resize(640, 480)
self.setWindowTitle("Preview")
class QGisMap(QtWidgets.QWidget, Ui_Form):
def __init__(self,projectfile,MainWidget):
QtWidgets.QMainWindow.__init__(self)
if os.name == 'nt':
ffmpeg = os.path.dirname(__file__)[0:-18]+'/Video_UAV_Tracker/FFMPEG/ffmpeg.exe'
versione = 'ffmpeg.exe'
else:
ffmpeg = os.path.dirname(__file__)+'/FFMPEG/./ffmpeg'
versione = 'ffmpeg'
if os.path.exists(ffmpeg) == True:
self.setupUi(self)
self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.Main = MainWidget
self.projectfile = projectfile
with open(self.projectfile,'r') as File:
for line in File:
if line[0:19] == 'Video file location':
self.videoFile = line.split('=')[-1][1:-1]
elif line[0:23] == 'Video start at msecond:':
self.fps = (1 / (float(line.split()[7]))) * 1000
self.StartMsecond = int(line.split()[4])
elif line[0:4] == 'DB =':
DB = line.split('=')[-1][1:-1]
if DB == 'None':
self.DB = None
else:
self.DB = DB
break
self.pushButton_3.setCheckable(True)
self.EnableMapTool = False
self.ExtractTool = 0
self.dockWidget_4.hide()
self.GPXList = []
self.positionMarker=PositionMarker(self.Main.iface.mapCanvas())
self.muteButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaVolume))
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
self.player = QMediaPlayer()
self.player.setVideoOutput(self.video_frame)
self.playButton.clicked.connect(self.PlayPause)
self.muteButton.clicked.connect(self.MuteUnmute)
self.toolButton_11.clicked.connect(self.SkipBackward)
self.toolButton_12.clicked.connect(self.SkipForward)
self.SkipBacktoolButton_8.clicked.connect(self.BackwardFrame)
self.SkipFortoolButton_9.clicked.connect(self.ForwardFrame)
self.toolButton_4.clicked.connect(self.ExtractToolbar)
self.toolButton_5.clicked.connect(self.close)
self.pushButtonCut_2.clicked.connect(self.ExtractCommand)
self.pushButtonCutA_6.clicked.connect(self.ExtractFromA)
self.pushButtonCutB_6.clicked.connect(self.ExtractToB)
self.pushButton_5.clicked.connect(self.CancelVertex)
self.progressBar.hide()
self.Main.pushButton_2.hide()
self.Main.pushButton_8.hide()
self.Main.groupBox.show()
self.Main.groupBox_4.hide()
self.ExtractA = False
self.ExtractB = False
self.ExtractedDirectory = None
self.pushButtonCut_2.setEnabled(False)
self.toolButton_6.setEnabled(False)
self.LoadGPXVideoFromPrj(self.projectfile)
else:
ret = QMessageBox.warning(self, "Warning", 'missing ffmpeg binaries, please download it from https://github.com/sagost/VideoUavTracker/blob/master/FFMPEG/'+versione+' and paste it in /.qgis3/python/plugins/Video_UAV_Tracker/FFMPEG/ ', QMessageBox.Ok)
self.close()
def LoadGPXVideoFromPrj(self,VideoGisPrj):
self.Polyline = []
with open(VideoGisPrj,'r') as File:
Counter = 0
for line in File:
if Counter < 5:
pass
else:
line = line.split()
lat = float(line[0])
lon = float(line[1])
ele = float(line[2])
speed = float(line[3])
course = float(line[4])
time = line[5]
Point = [lat,lon,ele,speed,course,time]
qgsPoint = QgsPoint(lon,lat)
self.Polyline.append(qgsPoint)
self.GPXList.append(Point)
Counter = Counter + 1
self.GpsLayer = QgsVectorLayer("LineString?crs=epsg:4326", self.videoFile.split('.')[-2].split('/')[-1], "memory")
self.pr = self.GpsLayer.dataProvider()
feat = QgsFeature()
feat.setGeometry(QgsGeometry.fromPolyline(self.Polyline))
self.pr.addFeatures([feat])
self.GpsLayer.updateExtents()
if self.DB != None:
try:
self.DBLayer = QgsVectorLayer(self.DB,self.DB.split('.')[-2].split('/')[-1],'ogr')
QgsProject.instance().addMapLayers([self.DBLayer,self.GpsLayer])
self.AddPointMapTool = AddPointTool(self.Main.iface.mapCanvas(),self.DBLayer,self)
self.toolButton_6.clicked.connect(self.AddPointTool)
self.toolButton_6.setEnabled(True)
except:
ret = QMessageBox.warning(self, "Warning", str(self.DB)+' is not a valid shapefile.', QMessageBox.Ok)
return
else:
QgsProject.instance().addMapLayers([self.GpsLayer])
self.duration = len(self.GPXList)
self.ExtractToB = self.duration
self.horizontalSlider.setSingleStep(1000)
self.horizontalSlider.setMinimum(0)
self.horizontalSlider.setMaximum(len(self.GPXList)*1000)
url = QUrl.fromLocalFile(str(self.videoFile))
mc = QMediaContent(url)
self.player.setMedia(mc)
self.player.setPosition(self.StartMsecond)
self.player.play()
self.horizontalSlider.sliderMoved.connect(self.setPosition)
self.player.stateChanged.connect(self.mediaStateChanged)
self.player.positionChanged.connect(self.positionChanged)
self.pushButton_3.clicked.connect(self.MapTool)
self.skiptracktool = SkipTrackTool( self.Main.iface.mapCanvas(),self.GpsLayer , self)
def AddPointTool(self):
self.Main.iface.mapCanvas().setMapTool(self.AddPointMapTool)
def MapTool(self):
if self.EnableMapTool == False:
self.Main.iface.mapCanvas().setMapTool(self.skiptracktool)
self.pushButton_3.setChecked(True)
self.EnableMapTool = True
else:
self.Main.iface.mapCanvas().unsetMapTool(self.skiptracktool)
self.pushButton_3.setChecked(False)
self.EnableMapTool = False
def closeEvent(self, *args, **kwargs):
try:
self.player.stop()
self.Main.iface.mapCanvas().scene().removeItem(self.positionMarker)
self.CancelVertex()
self.Main.pushButton_2.show()
#self.Main.horizontalSpacer_2.show()
self.Main.groupBox.hide()
self.Main.pushButton_8.show()
self.Main.groupBox_4.show()
self.dockWidget_2.close()
except:
pass
return QtWidgets.QWidget.closeEvent(self, *args, **kwargs)
def mediaStateChanged(self, state):
if self.player.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def setPosition(self, position):
self.player.setPosition(position+self.StartMsecond)
def secTotime(self,seconds):
m, s = divmod(seconds, 60)
h, m = divmod(m, 60)
return "%d:%02d:%02d" % (h, m, s)
def positionChanged(self, progress):
if progress < self.StartMsecond:
self.player.setPosition(self.StartMsecond)
progress = self.StartMsecond
AssociatedGps = round((progress - self.StartMsecond )/1000)
self.DisplayPoint(AssociatedGps)
totalTime = self.secTotime(self.duration)
actualTime = self.secTotime((progress - self.StartMsecond )/1000)
self.replayPosition_label.setText(actualTime + ' / '+totalTime)
if not self.horizontalSlider.isSliderDown():
self.horizontalSlider.setValue(progress - self.StartMsecond )
def DisplayPoint(self,Point):
if Point >= len(self.GPXList):
Point = len(self.GPXList) - 1
gpx = self.GPXList[Point]
lat = round(gpx[0],7)
lon = round(gpx[1],7)
ele = gpx[2]
speed = gpx[3]
course = gpx[4]
time = gpx[5]
Point = QgsPointXY()
Point.set(lon, lat)
canvas = self.Main.iface.mapCanvas()
crsSrc = QgsCoordinateReferenceSystem(4326) # .gpx is in WGS 84
crsDest = QgsProject.instance().crs()
xform = QgsCoordinateTransform(crsSrc, crsDest)
self.positionMarker.setHasPosition(True)
self.Point = xform.transform(Point)
self.positionMarker.newCoords(self.Point)
self.positionMarker.angle = float(course)
extent = canvas.extent()
boundaryExtent=QgsRectangle(extent)
boundaryExtent.scale(0.7)
if not boundaryExtent.contains(QgsRectangle(Point, self.Point)):
extentCenter= self.Point
newExtent=QgsRectangle(
extentCenter.x()-extent.width()/2,
extentCenter.y()-extent.height()/2,
extentCenter.x()+extent.width()/2,
extentCenter.y()+extent.height()/2
)
self.Main.iface.mapCanvas().setExtent(newExtent)
self.Main.iface.mapCanvas().refresh()
self.Main.label_14.setText('GPS Time: '+str(time))
self.Main.label_15.setText('Course: '+"%.2f" % (course))
self.Main.label_16.setText('Ele: '+"%.2f" %(ele))
self.Main.label_17.setText('Speed m/s: '+"%.2f" %(speed))
self.Main.label_19.setText('Lat : '+str(lat))
self.Main.label_18.setText('Lon : '+str(lon))
def MuteUnmute(self):
if self.player.mediaStatus() == 6 :
if self.player.isMuted() == 1:
self.player.setMuted(0)
self.muteButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaVolume))
elif self.player.isMuted() == 0:
self.player.setMuted(1)
self.muteButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaVolumeMuted))
def SkipForward(self):
position = self.player.position()
self.player.setPosition(position+1000)
def SkipBackward(self):
position = self.player.position()
self.player.setPosition(position-1000)
def ForwardFrame(self):
position = self.player.position()
self.player.setPosition(position+int(self.fps))
def BackwardFrame(self):
position = self.player.position()
self.player.setPosition(position-int(self.fps))
def PlayPause(self):
if self.player.state() == QMediaPlayer.PlayingState:
self.player.pause()
else:
self.player.play()
def findNearestPointInRecording(self, x,y):
ClickPt = QgsPoint(x,y)
Low = ClickPt.distanceSquared(self.Polyline[0])
NearPoint = 0
Counter = 0
for Point in self.Polyline:
dist = ClickPt.distanceSquared(Point)
if dist < Low:
Low = dist
NearPoint = Counter
Counter = Counter + 1
else:
Counter = Counter + 1
self.setPosition(NearPoint*1000)
def ExtractSingleFrameOnTime(self, pos, outputfile):
if os.name == 'nt':
ffmpeg = ('"'+os.path.dirname(__file__)[0:-18]+'/Video_UAV_Tracker/FFMPEG/ffmpeg.exe'+'"')
os.popen(str(ffmpeg)+' -ss '+str(pos/1000)+' -i '+str('"' +self.videoFile+ '"')+ ' -t 1 '+str('"'+outputfile+'"'))
else:
ffmpeg = os.path.dirname(__file__)+'/FFMPEG/./ffmpeg'
os.system(str(ffmpeg)+' -ss '+str(pos/1000)+' -i '+str(self.videoFile)+' -t 1 '+str(outputfile))
def AddPoint(self,x,y):
self.Main.iface.mapCanvas().unsetMapTool(self.AddPointMapTool)
Point = QgsPointXY(x,y)
pos = self.player.position()
if self.player.state() == QMediaPlayer.PlayingState:
self.player.pause()
a = self.DBLayer.name()
last_desc = '///'
LayerName =str(a)
last_desc2 = LayerName + ' Point N '
directory = str(self.DB.split('.')[0])+'_Image/'
if not os.path.exists(directory):
os.makedirs(directory)
fc = int(self.DBLayer.featureCount())
self.ExtractSingleFrameOnTime(pos,directory+LayerName+'_'+str(fc)+'_.jpg')
fields = self.DBLayer.fields()
attributes = []
lat,lon = Point.y(), Point.x()
for field in fields:
a = str(field.name())
b = str(field.typeName())
if a == 'id':
fcnr = fc
attributes.append(fcnr)
elif a == 'Lon(WGS84)':
attributes.append(str(lon))
elif a == 'Lat(WGS84)':
attributes.append(str(lat))
elif a == 'Image link':
attributes.append(str(directory+LayerName+'_'+str(fc)+'_.jpg'))
else:
if b == 'String':
(a,ok) = QInputDialog.getText(
self.Main.iface.mainWindow(),
"Attributes",
a + ' = String',
QLineEdit.Normal)
attributes.append(a)
elif b == 'Real':
(a,ok) = QInputDialog.getDouble(
self.Main.iface.mainWindow(),
"Attributes",
a + ' = Real', decimals = 10)
attributes.append(a)
elif b == 'Integer64':
(a,ok) = QInputDialog.getInt(
self.Main.iface.mainWindow(),
"Attributes",
a + ' = Integer')
attributes.append(a)
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPoint(Point))
feature.setAttributes(attributes)
self.DBLayer.startEditing()
self.DBLayer.addFeature(feature)
self.DBLayer.commitChanges()
self.DBLayer.triggerRepaint()
def ExtractCommand(self):
if self.ExtractToB <= self.ExtractFromA:
ret = QMessageBox.warning(self, "Warning", '"To B" point must be after "from A" point', QMessageBox.Ok)
self.CancelVertex()
else:
if os.name == 'nt':
ffmpeg = '"'+os.path.dirname(__file__)[0:-18]+'/Video_UAV_Tracker/FFMPEG/ffmpeg.exe'+'"'
else:
ffmpeg = os.path.dirname(__file__)+'/FFMPEG/./ffmpeg'
Directory,_ = QFileDialog.getSaveFileName(caption= 'Save georeferenced images')
if Directory:
self.progressBar.show()
self.progressBar.setValue(0)
start = self.ExtractFromA
if self.comboBox_6.currentText() == 'seconds':
finish = self.ExtractToB - self.ExtractFromA
fps = self.doubleSpinBox_2.value()
if fps < 1.0:
fps = 1.0 / fps
elif fps > 1:
fps = 1.0 / fps
if os.name == 'nt':
os.popen(str(ffmpeg+ ' -ss ' + str(start) + ' -i '+ str('"'+self.videoFile+'"')+ ' -t ' + str(finish) + ' -vf fps=' + str(fps) + ' ' + '"'+Directory + '_%d.png'+'"'))
else:
os.system(ffmpeg+' -ss '+ str(start) + ' -i '+ str(self.videoFile) + ' -t ' + str(finish) + ' -vf fps=' + str(fps) + ' ' + Directory + '_%d.png')
else:
txtGPSFile = open(Directory + 'UTM_Coordinates.txt', 'w')
txtGPSFile.close()
txtGPSFile = open(Directory+ 'UTM_Coordinates.txt', 'a')
txtGPSFile.write('filename # East UTM # North UTM # Ele '+ '\n')
finish = self.ExtractToB
meters = self.doubleSpinBox_2.value()
Timerange = range(start, finish + 1)
RemainToUseMeterTotal = 0
if os.name == 'nt':
os.popen(ffmpeg+' -ss '+ str(start) + ' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' + '"'+Directory + '_sec_' + str(start)+'.00.png'+'"')
else:
os.system(ffmpeg+' -ss '+ str(start) + ' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(start)+'.00.png')
lonUTM, latUTM,quotainutile = self.transform_wgs84_to_utm(float(self.GPXList[start][1]) , float(self.GPXList[start][0]))
ele = float(self.GPXList[start][2])
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(start)+'.00.png,'+' '+ str(lonUTM) + ', '+ str(latUTM) + ', ' + str(ele) + '\n')
for i in Timerange:
progessBarValue = ((i-start) * 100) // len(Timerange)
self.progressBar.setValue(int(progessBarValue))
latitude1,longitude1 = float(self.GPXList[i][0]) ,float(self.GPXList[i][1])
latitude2,longitude2 = float(self.GPXList[i+1][0]) ,float(self.GPXList[i+1][1])
ele1 = float(self.GPXList[i][2])
ele2 = float(self.GPXList[i+1][2])
Calculus = Geodesic.WGS84.Inverse(latitude1, longitude1, latitude2, longitude2)
DistanceBetweenPoint = Calculus['s12']
Azimuth = Calculus['azi2']
SpeedMeterSecond = DistanceBetweenPoint #GPS refresh rate is actually 1, change parameter for different rates
# Time = 1
if RemainToUseMeterTotal == 0:
if DistanceBetweenPoint >= meters:
decimalSecondToAdd = meters / DistanceBetweenPoint
RemainToUseMeter = DistanceBetweenPoint - meters
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' + str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
while RemainToUseMeter > meters:
decimalSecondToAddMore = meters / SpeedMeterSecond
RemainToUseMeter = RemainToUseMeter - meters
decimalSecondToAdd = decimalSecondToAdd + decimalSecondToAddMore
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' + str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
if RemainToUseMeter == meters:
decimalSecondToAddMore = meters / SpeedMeterSecond
RemainToUseMeter = RemainToUseMeter - meters
decimalSecondToAdd = decimalSecondToAdd + decimalSecondToAddMore
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' +str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
RemainToUseMeterTotal = 0
elif RemainToUseMeter < meters:
RemainToUseMeterTotal = RemainToUseMeter
pass
else:
RemainToUseMeterTotal = meters - DistanceBetweenPoint
elif RemainToUseMeterTotal > 0:
if DistanceBetweenPoint >= (meters - RemainToUseMeterTotal) :
decimalSecondToAdd = (meters - RemainToUseMeterTotal) / DistanceBetweenPoint
RemainToUseMeter = DistanceBetweenPoint - (meters - RemainToUseMeterTotal)
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' + str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
while RemainToUseMeter > meters:
decimalSecondToAddMore = meters / SpeedMeterSecond
RemainToUseMeter = RemainToUseMeter - meters
decimalSecondToAdd = decimalSecondToAdd + decimalSecondToAddMore
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' + str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
if RemainToUseMeter == meters:
decimalSecondToAddMore = meters / SpeedMeterSecond
RemainToUseMeter = RemainToUseMeter - meters
decimalSecondToAdd = decimalSecondToAdd + decimalSecondToAddMore
if os.name == 'nt':
os.popen(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str('"'+self.videoFile+'"') + ' -frames:v 1 ' +'"'+ Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png'+'"')
else:
os.system(ffmpeg+ ' -ss '+ str(i + decimalSecondToAdd) +
' -i '+ str(self.videoFile) + ' -frames:v 1 ' + Directory + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4] +'.png')
CalculusDirect = Geodesic.WGS84.Direct(latitude1, longitude1, Azimuth,decimalSecondToAdd* SpeedMeterSecond)
X,Y,quotainutile = self.transform_wgs84_to_utm(CalculusDirect['lon2'],CalculusDirect['lat2'] )
Z = ele1 + decimalSecondToAdd*(ele2 - ele1)
txtGPSFile.write(str(Directory.split('/')[-1]) + '_sec_' + str(i) + str(decimalSecondToAdd)[1:4]+'.png,' + ' ' + str(X) + ', ' + str(Y) + ', ' + str(Z) + '\n')
RemainToUseMeterTotal = 0
elif RemainToUseMeter < meters:
RemainToUseMeterTotal = RemainToUseMeter
else:
RemainToUseMeterTotal = (meters - DistanceBetweenPoint) + RemainToUseMeterTotal
txtGPSFile.close()
self.progressBar.hide()
def ExtractFromA(self):
if self.ExtractA == True:
self.Main.iface.mapCanvas().scene().removeItem(self.ExtractAVertex)
self.ExtractA = False
self.ExtractFromA = round((self.player.position()- self.StartMsecond )/1000)
canvas = self.Main.iface.mapCanvas()
crsSrc = QgsCoordinateReferenceSystem(4326) # .gpx is in WGS 84
crsDest = QgsProject.instance().crs()
xform = QgsCoordinateTransform(crsSrc, crsDest)
latitude,longitude = self.Polyline[self.ExtractFromA].y(), self.Polyline[self.ExtractFromA].x()
self.ExtractAVertex = QgsVertexMarker(canvas)
self.ExtractAVertex.setCenter(xform.transform(QgsPointXY(longitude, latitude)))
self.ExtractAVertex.setColor(QColor(0,255,0))
self.ExtractAVertex.setIconSize(10)
self.ExtractAVertex.setIconType(QgsVertexMarker.ICON_X)
self.ExtractAVertex.setPenWidth(10)
self.ExtractA = True
if self.ExtractB == True:
self.pushButtonCut_2.setEnabled(True)
else:
self.pushButtonCut_2.setEnabled(False)
def ExtractToB(self):
if self.ExtractB == True:
self.Main.iface.mapCanvas().scene().removeItem(self.ExtractBVertex)
self.ExtractB = False
self.ExtractToB = round((self.player.position()- self.StartMsecond )/1000)
if self.ExtractA == True:
if self.ExtractToB > self.ExtractFromA:
canvas = self.Main.iface.mapCanvas()
crsSrc = QgsCoordinateReferenceSystem(4326) # .gpx is in WGS 84
crsDest = QgsProject.instance().crs()
xform = QgsCoordinateTransform(crsSrc, crsDest)
latitude,longitude = self.Polyline[self.ExtractToB].y(), self.Polyline[self.ExtractToB].x()
self.ExtractBVertex = QgsVertexMarker(canvas)
self.ExtractBVertex.setCenter(xform.transform(QgsPointXY(longitude, latitude)))
self.ExtractBVertex.setColor(QColor(255,0,0))
self.ExtractBVertex.setIconSize(10)
self.ExtractBVertex.setIconType(QgsVertexMarker.ICON_X)
self.ExtractBVertex.setPenWidth(10)
self.ExtractB = True
self.pushButtonCut_2.setEnabled(True)
else:
self.pushButtonCut_2.setEnabled(False)
def CancelVertex(self):
if self.ExtractA == True:
self.Main.iface.mapCanvas().scene().removeItem(self.ExtractAVertex)
self.ExtractA = False
if self.ExtractB == True:
self.Main.iface.mapCanvas().scene().removeItem(self.ExtractBVertex)
self.ExtractB = False
self.pushButtonCut_2.setEnabled(False)
def ExtractToolbar(self):
if self.ExtractTool == 0:
self.dockWidget_4.show()
self.ExtractTool = 1
else:
self.dockWidget_4.hide()
self.ExtractTool = 0
def transform_wgs84_to_utm(self, lon, lat):
def get_utm_zone(longitude):
return (int(1+(longitude+180.0)/6.0))
def is_northern(latitude):
"""
Determines if given latitude is a northern for UTM
"""
if (latitude < 0.0):
return 0
else:
return 1
utm_coordinate_system = osr.SpatialReference()
utm_coordinate_system.SetWellKnownGeogCS("WGS84") # Set geographic coordinate system to handle lat/lon
utm_coordinate_system.SetUTM(get_utm_zone(lon), is_northern(lat))
wgs84_coordinate_system = utm_coordinate_system.CloneGeogCS() # Clone ONLY the geographic coordinate system
wgs84_to_utm_transform = osr.CoordinateTransformation(wgs84_coordinate_system, utm_coordinate_system) # (<from>, <to>)
return wgs84_to_utm_transform.TransformPoint(lon, lat, 0) # returns easting, northing, altitude
app = QApplication(sys.argv)
# create stacked layout
w = QStackedWidget()
# add buttons
btn1 = QPushButton("PLAY")
player = QMediaPlayer()
media = QMediaContent(QUrl(sys.argv[1]))
player.setMedia(media)
# Create and set video output widget
video = ClickableVideoWidget()
player.setVideoOutput(video)
# add to stacked layout
print("Added widget", w.addWidget(btn1))
print("Added widget", w.addWidget(video))
def play_video():
w.setCurrentIndex(1)
player.play()
def pause_video():
player.pause()
w.setCurrentIndex(0)
# connect signals to stack change layout slot
btn1.clicked.connect(play_video)
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 GameWindow(QWidget):
def __init__(self, parent=None):
super(GameWindow,self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.stringLabel = QLabel()
self.stringLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
self.stringLabel.setTextFormat(Qt.RichText)
self.stringLabel.setAlignment(Qt.AlignHCenter)
layout = QVBoxLayout()
layout.addWidget(self.videoWidget)
layout.addWidget(self.stringLabel)
self.setLayout(layout)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
def openFile(self, fileName):
if fileName != '':
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(fileName)))
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def playV(self, file, rate, visibility, labelString):
self.position = 0
self.startPos = 0
self.duration = 0
self.durChanged = False
self.stopPos = False
self.openFile(file)
self.mediaPlayer.setPlaybackRate(rate)
if visibility:
self.videoWidget.show()
self.stringLabel.show()
self.stringLabel.setText(labelString)
else:
self.videoWidget.hide()
self.stringLabel.show()
self.stringLabel.setText(labelString)
self.play()
def closeEvent(self, event):
event.ignore()
self.mediaPlayer.stop()
super(GameWindow, self).closeEvent(event)
def positionChanged(self, pos):
self.position = pos
if not self.durChanged and self.position > 0:
self.durationChanged(self.mediaPlayer.duration())
self.durChanged = True
if self.startPos > 0 and not self.stopPos and not self.videoWidget.isVisible():
if self.position > self.startPos + 20000:
self.play()
self.stopPos = True
def durationChanged(self, dur):
self.duration = dur
if self.duration > 40000 and not self.videoWidget.isVisible():
self.startPos = random.randint(5000, self.duration - 25000)
self.mediaPlayer.setPosition(self.startPos)
def showPoints(self, pointsString):
self.videoWidget.hide()
self.stringLabel.show()
self.stringLabel.setText(pointsString)
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 VideoPlayer(QWidget):
"""
Arguments
---------
parent: QWidget, the parent widget of VideoPlayer
display_status: bool, default False, will show the status of the media player in the gui
"""
def __init__(self, parent=None, display_status=False):
super(VideoPlayer, self).__init__(parent)
self.display_status = display_status
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoItem = QGraphicsVideoItem()
scene = QGraphicsScene(self)
graphicsView = QGraphicsView(scene)
scene.addItem(self.videoItem)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
if self.display_status:
self.status_mapping = {
QMediaPlayer.UnknownMediaStatus: "UnknownMediaStatus",
QMediaPlayer.NoMedia: "NoMedia",
QMediaPlayer.LoadingMedia: "LoadingMedia",
QMediaPlayer.LoadedMedia: "LoadedMedia",
QMediaPlayer.StalledMedia: "StalledMedia",
QMediaPlayer.BufferingMedia: "BufferingMedia",
QMediaPlayer.BufferedMedia: "BufferedMedia",
QMediaPlayer.EndOfMedia: "EndOfMedia",
QMediaPlayer.InvalidMedia: "InvalidMedia"
}
self.statusText = QPlainTextEdit()
self.statusText.setReadOnly(True)
self.statusText.setFixedHeight(25)
self.statusText.setFixedWidth(150)
self.mediaPlayer.mediaStatusChanged.connect(self.mediaStatusChanged)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
if self.display_status:
controlLayout.addWidget(self.statusText)
layout = QVBoxLayout()
layout.addWidget(graphicsView)
layout.addLayout(controlLayout)
self.setFixedWidth(WIDTH + WIGGLE)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(self.videoItem)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
def openFile(self, fileName):
if fileName != '' or fileName is not None:
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
# set resolution
res_orig = get_video_resolution(fileName)
self.aspect_ratio = float(res_orig[0]) / res_orig[1]
self.videoItem.setSize(QSizeF(WIDTH,
WIDTH / self.aspect_ratio))
self.setFixedHeight(WIDTH / self.aspect_ratio + 2*WIGGLE)
self.playButton.setEnabled(True)
# trick to show screenshot of the first frame of video
self.mediaPlayer.play()
self.mediaPlayer.pause()
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def mediaStatusChanged(self, status):
self.statusText.setPlaceholderText(self.status_mapping[status])
def positionChanged(self, position):
self.positionSlider.setValue(position)
print self.positionSlider.value()
# if position slider has reached the end, let's stop the video
if self.positionSlider.value() >= self.positionSlider.maximum() - 1:
self.mediaPlayer.stop()
# play/pause hack to show the first frame of video
self.mediaPlayer.play()
self.mediaPlayer.pause()
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
class NewProject(QtWidgets.QWidget, Ui_NewProject):
def __init__(self,projectfile,MainWidget):
QtWidgets.QWidget.__init__(self)
self.setupUi(self)
self.setWindowFlags(Qt.WindowStaysOnTopHint)
self.Main = MainWidget
self.iface = self.Main.iface
self.muteButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaVolume))
self.replayPlay_pushButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
if projectfile.split('.')[-1] =="vgp":
self.projectfile = projectfile
else:
self.projectfile = projectfile +'.vgp'
self.videofile = None
self.GPXfile = None
self.GPXList = None
self.fps = None
self.RealFps = None
self.DB = None
self.player = QMediaPlayer()
self.player.setVideoOutput(self.video_frame_2)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
self.player.stateChanged.connect(self.mediaStateChanged)
self.toolButton_3.clicked.connect(self.ManageDB)
self.pushButton_2.clicked.connect(self.Synchronize)
self.pushButton.clicked.connect(self.SelectVideoGPX)
self.replayPlay_pushButton.clicked.connect(self.PlayPause)
self.muteButton.clicked.connect(self.MuteUnmute)
self.horizontalSlider.sliderMoved.connect(self.setPosition)
self.toolButton.clicked.connect(self.SkipBackward)
self.toolButton_2.clicked.connect(self.SkipForward)
self.SkipBacktoolButton_7.clicked.connect(self.BackwardFrame)
self.SkipFortoolButton_8.clicked.connect(self.ForwardFrame)
def closeEvent(self, *args, **kwargs):
self.player.stop()
return QtWidgets.QWidget.closeEvent(self, *args, **kwargs)
def mediaStateChanged(self, state):
if self.player.state() == QMediaPlayer.PlayingState:
self.replayPlay_pushButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.replayPlay_pushButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def Synchronize(self):
TimeItem = self.comboBox.currentIndex()
duration = self.player.duration()
position = self.player.position()
VideoPartLen = round((duration-position) / 1000)
GpxPartition = self.GPXList[TimeItem:VideoPartLen+TimeItem]
outputFile = open(self.projectfile ,'w')
if self.DB == None:
outputFile.write('VideoGis Project v0.1 DO NOT MODIFY'+
'\nVideo file location = ' +self.videofile+
'\nVideo start at msecond: '+
str(self.player.position())+
' #fps = '+str(self.RealFps)+
'\nDB = None'+
'\n'+'Latitude # Longitude # Ele # Speed (m/s) # Course # Time \n')
else:
outputFile.write('Video file location = ' +self.videofile+
'\nVideo start at msecond: '+
str(self.player.position())+
' #fps = '+str(self.RealFps)+
'\nDB = '+str(self.DB.dataProvider().dataSourceUri().split('|')[0])+
'\n'+'Latitude # Longitude # Ele # Speed (m/s) # Course # Time \n')
Counter = 0
for x in GpxPartition:
if Counter != 0:
ActualLatitude = x[1][0]
ActualLongitude = x[1][1]
PreviousLatitude = GpxPartition[Counter-1][1][0]
PreviousLongitude = GpxPartition[Counter-1][1][1]
GeodesicCalcolus = Geodesic.WGS84.Inverse(PreviousLatitude, PreviousLongitude, ActualLatitude, ActualLongitude)
Speed = GeodesicCalcolus['s12'] /1
Course = GeodesicCalcolus['azi2']
if Course < 0:
Course += 360
Ele = x[1][2]
Time = x[1][3]
Counter = Counter + 1
else:
ActualLatitude = x[1][0]
ActualLongitude = x[1][1]
PreviousLatitude = GpxPartition[Counter+1][1][0]
PreviousLongitude = GpxPartition[Counter+1][1][1]
GeodesicCalcolus = Geodesic.WGS84.Inverse(ActualLatitude, ActualLongitude, PreviousLatitude, PreviousLongitude)
Speed = GeodesicCalcolus['s12'] * 1
Course = GeodesicCalcolus['azi2']
if Course < 0:
Course += 360
Ele = x[1][2]
Time = x[1][3]
Counter = Counter + 1
outputFile.write(str(ActualLatitude)+' '+str(ActualLongitude)+' '+str(Ele)+' '+str(Speed)+' '+str(Course)+' '+str(Time)+'\n')
outputFile.close()
self.Main.LoadProjFromNew(self.projectfile)
if os.name == 'nt':
os.remove (self.tmp)
self.close()
def SelectVideoGPX(self):
if os.name == 'nt':
ffmpeg = os.path.dirname(__file__)+'/FFMPEG/ffmpeg.exe'
versione = 'ffmpeg.exe'
else:
ffmpeg = os.path.dirname(__file__)+'/FFMPEG/./ffmpeg'
versione = 'ffmpeg'
if os.path.exists(ffmpeg) == True:
self.comboBox.clear()
if self.player.state() == QMediaPlayer.PlayingState:
self.player.pause()
self.videofile = None
self.GPXfile = None
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
self.videofile, _ = QFileDialog.getOpenFileName(self,"Select Video File", "","All Files (*);;Video File (*.mp4 *.avi *.ogv)", options=options)
if self.videofile:
self.GPXfile, _ = QFileDialog.getOpenFileName(self,"Select GPX file", "","All Files (*);;Video File (*.gpx)", options=options)
if self.GPXfile:
self.ParseGpx(self.GPXfile)
self.LoadVideo(self.videofile)
self.replayPosition_label.setText( "-:- / -:-")
else:
ret = QMessageBox.warning(self, "Warning", 'missing ffmpeg binaries, please download it from https://github.com/sagost/VideoUavTracker/blob/master/FFMPEG/'+versione+' and paste it in /.qgis3/python/plugins/Video_UAV_Tracker/FFMPEG/ ', QMessageBox.Ok)
self.close()
def ParseGpx(self,GPXfile):
gpx = parse(GPXfile)
track = gpx.getElementsByTagName("trkpt")
GPXList = []
Error = 0
GpxProgressiveNumber = 0
Timestamp = 'Segnaposto'
for name in track:
dict = {'Lat': 0, 'Lon': 0, 'Ele': 0, 'Time':0}
a = (name.toprettyxml(indent = '') ).split()
for x in a:
if x.find('lat') == 0:
lat = float(x.split('"')[1])
dict['Lat'] = float(x.split('"')[1])
elif x.find('lon') == 0:
lon = float(x.split('"')[1])
dict['Lon'] = float(x.split('"')[1])
elif x.find('<ele>') == 0:
dict['Ele'] = float(x[5:-6])
elif x.find('<time>') == 0:
try:
gpxtime = time.strftime('%Y-%m-%dT%H:%M:%S.%fZ',time.strptime(x[6:-7], '%Y-%m-%dT%H:%M:%S.%fZ'))
dict['Time']= x[6:-7]
except ValueError:
try:
gpxtime = time.strftime('%Y-%m-%dT%H:%M:%SZ',time.strptime(x[6:-7],'%Y-%m-%dT%H:%M:%SZ'))
dict['Time']= x[6:-7]
except ValueError:
try:
gpxtime = time.strftime('%Y-%m-%dT%H:%M:%S',time.strptime(x[6:-7],'%Y-%m-%dT%H:%M:%S'))
dict['Time']= x[6:-7]
except ValueError:
try:
gpxtime = time.strftime('%Y-%m-%dT%H.%M.%S',time.strptime(x[6:-7],'%Y-%m-%dT%H.%M.%S'))
dict['Time']= x[6:-7]
except ValueError:
try:
gpxtime = time.strftime('%Y-%m-%dT%H.%M.%S',time.strptime(x[6:-13],'%Y-%m-%dT%H.%M.%S'))
dict['Time']= x[6:-13]
except ValueError:
try:
gpxtime = time.strftime('%Y-%m-%dT%H.%M.%S',time.strptime(x[6:-13],'%Y-%m-%dT%H:%M:%S'))
dict['Time']= x[6:-13]
except ValueError:
Error = 1
FormatoErrore = str(x)
if dict['Time'] != Timestamp:
Point = [dict['Lat'],dict['Lon'],dict['Ele'],dict['Time']]
self.comboBox.addItem(str(GpxProgressiveNumber) + '-'+gpxtime )
GPXList.append([GpxProgressiveNumber,Point])
GpxProgressiveNumber = GpxProgressiveNumber + 1
Timestamp = dict['Time']
else:
Timestamp = dict['Time']
if Error == 0:
self.GPXList = GPXList
else:
ret = QMessageBox.warning(self, "Warning", FormatoErrore +' UNKOWN GPX TIME FORMAT - ABORTED', QMessageBox.Ok)
self.close
def LoadVideo(self,videofile):
fps = self.getVideoDetails(str(videofile))
self.RealFps = float(fps)
self.fps = (1 / self.RealFps )*1000
url = QUrl.fromLocalFile(str(self.videofile))
mc = QMediaContent(url)
self.player.setMedia(mc)
self.player.play()
def setPosition(self, position):
self.player.setPosition(position*1000)
def durationChanged(self, duration):
duration /= 1000
self.horizontalSlider.setMaximum(duration)
def secTotime(self,seconds):
m, s = divmod(seconds, 60)
h, m = divmod(m, 60)
return "%d:%02d:%02d" % (h, m, s)
def positionChanged(self, progress):
duration = self.player.duration()
totalTime = self.secTotime(duration/1000)
actualTime = self.secTotime(progress/1000)
self.replayPosition_label.setText(actualTime + ' / '+totalTime)
progress /= 1000
if not self.horizontalSlider.isSliderDown():
self.horizontalSlider.setValue(progress)
def MuteUnmute(self):
if self.player.mediaStatus() == 6 :
if self.player.isMuted() == 1:
self.player.setMuted(0)
self.muteButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaVolume))
elif self.player.isMuted() == 0:
self.player.setMuted(1)
self.muteButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaVolumeMuted))
def PlayPause(self):
if self.player.state() == QMediaPlayer.PlayingState:
self.player.pause()
else:
self.player.play()
def getVideoDetails(self,filepath):
if os.name == 'nt':
tmp = os.path.dirname(__file__)[0:-18]+'/Video_UAV_Tracker/tmp'
tmp2 = '"'+tmp+'"'
filepath2 = '"'+filepath+'"'
a = open(tmp,'w')
a.close()
ffmpeg = '"'+os.path.dirname(__file__)[0:-18]+'/Video_UAV_Tracker/FFMPEG/ffmpeg.exe'+'"'
a = os.popen(str(ffmpeg + ' -i '+filepath2+' 2> '+tmp2))
while os.stat(tmp).st_size < 1500:
pass
a = open(tmp,'r')
lines = a.readlines()
a.close()
for l in lines:
l = l.strip()
if str(l).startswith("Stream #0:0"):
linea = str(l).split(',')[-4]
dopo = linea.find('fps')
fps = float(linea[0:dopo])
self.tmp = tmp
return fps
else:
tmpf = tempfile.NamedTemporaryFile()
ffmpeg = os.path.dirname(__file__)+'/FFMPEG/./ffmpeg'
os.system(str(ffmpeg)+" -i \"%s\" 2> %s" % (filepath, tmpf.name))
lines = tmpf.readlines()
tmpf.close()
for l in lines:
l = l.strip()
if str(l).startswith("b'Stream #0:0"):
linea = str(l).split(',')[-4]
dopo = linea.find('fps')
fps = float(linea[0:dopo])
return fps
def SkipForward(self):
position = self.player.position()
self.player.setPosition(position+1000)
def SkipBackward(self):
position = self.player.position()
self.player.setPosition(position-1000)
def ForwardFrame(self):
position = self.player.position()
self.player.setPosition(position+int(self.fps))
def BackwardFrame(self):
position = self.player.position()
self.player.setPosition(position-int(self.fps))
def ManageDB(self):
self.player.pause()
shapeFileFirst,_ = QFileDialog.getSaveFileName(caption = 'Save shape file', filter = "Esri shp (*.shp)")
if shapeFileFirst:
if shapeFileFirst.split('.')[-1] == 'shp':
shapeFile = shapeFileFirst
else:
shapeFile = shapeFileFirst + '.shp'
try:
os.remove(shapeFile)
os.remove(shapeFileFirst.split('.')[0]+'.qpg')
os.remove(shapeFileFirst.split('.')[0]+'.prj')
os.remove(shapeFileFirst.split('.')[0]+'.cpg')
os.remove(shapeFileFirst.split('.')[0]+'.shx')
os.remove(shapeFileFirst.split('.')[0]+'.dbf')
except OSError:
pass
crs = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
fields = QgsFields()
QgsVectorFileWriter(shapeFile, "CP1250", fields, QgsWkbTypes.Point, crs, "ESRI Shapefile")
EmptyLayer = QgsVectorLayer(shapeFile, shapeFile.split('.')[0].split('/')[-1], 'ogr')
self.dialoga = TableManager(self.iface, EmptyLayer,self)
self.dialoga.exec_()
def AcceptNewDB(self,DB):
self.DB = DB
class MainWindow(QMainWindow, Ui_MainWindow):
settings = QSettings('Rafał Jagoda', 'Peer 2 cinema')
settings.setFallbacksEnabled(False)
version = '1.0'
def __init__( self, parent=None ):
QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.media_player = None
self.setWindowTitle('name of the software - ' + self.version)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.show()
self.timer = QTimer(self)
self.current_category = None
def play(self, movie: Movie):
self.app.play(movie)
self.media_player.play()
self.playButton.setEnabled(True)
def connect_app(self, app: P2CDaemon):
self.app = app
self._set_categories()
self._connect_signals()
def change_category(self, item):
index = self.menuTree.indexOfTopLevelItem(item)
category = self.app.get_categories()[index]
self.current_category = category
self.itemList.clear()
threading.Thread(target=self._set_torrents).start()
def activate_torrent(self, item):
self.update_status()
def update_status(self):
index = self.itemList.currentIndex().row()
if index != -1:
data= {}
torrent_ui = self.current_category.get_torrents()[index]
torrent = self.app.get_torrent(torrent_ui)
if torrent and torrent.has_torrent_info():
movie = torrent.get_downloading_movie()
if movie:
data['movie'] = movie.name
if self.media_player:
self.positionSlider.setBackgroundValue(movie.progress * self.media_player.duration())
data['movie progress'] = "{0:.2f}%".format(movie.progress * 100)
data['can_play'] = movie.can_play()
data.update(torrent.get_status())
# TODO: buggy due to setting priority to 0
if data['state'] == 'downloading':
del data['progress']
else:
data['progress'] = "{0:.2f}%".format(data['progress'] * 100)
data['download_rate'] = "{0:.2f} kb/s".format(data['download_rate']/1000)
else:
data['status'] = "Getting metadata"
text = "\n".join(["{}: {}".format(k,data[k]) for k in data])
else:
text="select item"
self.statusArea.setText(text)
def run_torrent(self, item):
index = self.itemList.currentIndex()
torrent_ui = self.current_category.get_torrents()[index.row()]
torrent = self.app.get_torrent(torrent_ui)
if(torrent.has_torrent_info()):
movies = torrent.get_movies()
# DEVELOPMENT
movie = max(movies, key=lambda x:x.size)
torrent.download_file(movie.path)
if(movie.can_play()):
self._set_media(movie)
self.play(movie)
else:
self.app.buffer(movie)
def _set_categories(self):
for category in self.app.get_categories():
item = QTreeWidgetItem(self.menuTree)
item.setText(0, category.label)
def _set_torrents(self):
category = self.current_category
items = map(lambda x: x.label,
category.get_torrents(limit=20))
# after long call
if(self.current_category == category):
self.itemList.addItems(list(items))
def toggle_player(self):
if self.media_player.state() == QMediaPlayer.PlayingState:
self.media_player.pause()
else:
self.media_player.play()
def set_player_position(self, position):
self.media_player.setPosition(position)
def media_state_changed(self, state):
if state == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.videoArea.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(self.videoArea.style().standardIcon(QStyle.SP_MediaPlay))
def position_changed(self, position):
self.positionSlider.setValue(position)
def duration_changed(self, duration):
self.positionSlider.setRange(0, duration)
def _connect_signals(self):
self.menuTree.currentItemChanged.connect(self.change_category)
self.itemList.currentItemChanged.connect(self.activate_torrent)
self.itemList.itemDoubleClicked.connect(self.run_torrent)
self.timer.timeout.connect(self.update_status)
self.timer.start(500)
def _connect_player_signals(self):
self.playButton.clicked.connect(self.toggle_player)
self.positionSlider.sliderMoved.connect(self.set_player_position)
self.media_player.stateChanged.connect(self.media_state_changed)
self.media_player.durationChanged.connect(self.duration_changed)
self.media_player.positionChanged.connect(self.position_changed)
def _set_media(self, movie: Movie):
if self.media_player is None:
self.media_player = QMediaPlayer(self.videoArea,
QMediaPlayer.VideoSurface)
self.media_player.setVideoOutput(self.videoArea.videoSurface())
self._connect_player_signals()
file_name = movie.get_target_path()
mimetype = mimetypes.guess_type(file_name)[0]
logger.debug("Found mimetype: {}".format(mimetype))
media_res = QMediaResource(QUrl.fromLocalFile(file_name), mimetype)
media = QMediaContent(media_res)
self.media_player.setMedia(media)
class VideoSortApp(QMainWindow, Ui_MainWindow, QWidget):
def __init__(self):
super(VideoSortApp, self).__init__()
self.setupUi(self)
self.filename = None
self.directory = None
self.sort.setEnabled(False)
self.fileOpen.clicked.connect(self.fileDialog)
self.dirOpen.clicked.connect(self.folderDialog)
self.sort.clicked.connect(self.sortVideo)
self.results.setViewMode(self.results.IconMode)
self.results.setResizeMode(self.results.Adjust)
self.features = []
self.sorted = None
#player properties
self.player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.playlist = QMediaPlaylist(self.player)
self.videoItem = QGraphicsVideoItem()
self.videoItem.setSize(QtCore.QSizeF(640, 480))
scene = QGraphicsScene(self)
scene.addItem(self.videoItem)
self.graphicsView.setScene(scene)
self.player.setVideoOutput(self.videoItem)
self.graphicsView.resize(640,480)
self.graphicsView.show()
self.results.itemDoubleClicked.connect(self.seekVideo)
self.videoLoaded = False
def sizeHint(self):
return QtCore.QSize(640,480)
def fileDialog(self):
dialog = QFileDialog()
if dialog.getOpenFileName:
self.filename = dialog.getOpenFileName()[0]
self.sort.setEnabled(True)
def folderDialog(self):
dialog = QFileDialog()
if dialog.getExistingDirectory:
self.directory = dialog.getExistingDirectory()
self.sort.setEnabled(True)
def sortVideo(self):
dialog = QFileDialog()
folder = dialog.getExistingDirectory(self, 'Select output directory for thumbnail images')
if folder:
if self.filename:
self.getThread = VideoSort(self.filename, folder, 'frame')
#self.results.setIconSize(QtCore.QSize(self.getThread.thumbInfo['resolution'][0], self.getThread.thumbInfo['resolution'][1]))
#slot
self.getThread.resultsSignal.connect(self.setFeatures)
self.getThread.start()
self.player.setMedia(QMediaContent(QtCore.QUrl.fromLocalFile(self.filename)))
self.currentMedia = self.filename
if self.directory:
formatList = ['.mp4', '.mov', '.mkv', '.avi']
for dirname, dirnames, filenames in os.walk(self.directory):
supportedFiles = [os.path.abspath(os.path.join(dirname, path)) for path in filenames if os.path.splitext(path)[1] in formatList]
for filename in supportedFiles:
self.getThread = VideoSort(filename, folder, os.path.splitext(filename.split('/')[-1])[0])
self.getThread.resultsSignal.connect(self.setFeatures)
self.getThread.start()
self.player.setMedia(QMediaContent(QtCore.QUrl.fromLocalFile(filename)))
#Just set the last file as the current file
self.player.setMedia(QMediaContent(QtCore.QUrl.fromLocalFile(filename)))
self.currentMedia = filename
def setFeatures(self, features):
for feature in features:
self.features.append(feature)
self.hue.toggled.connect(self.displayResults)
self.saturation.toggled.connect(self.displayResults)
self.contours.toggled.connect(self.displayResults)
def displayResults(self):
self.results.clear()
if self.hue.isChecked():
sortedFeatures = sorted(self.features, key=lambda res: res['hue']['std'], reverse=False)
self.sorted = True
if self.saturation.isChecked():
sortedFeatures = sorted(self.features, key=lambda res: res['sat']['std'], reverse=False)
self.sorted = True
if self.contours.isChecked():
sortedFeatures = sorted(self.features, key=lambda res: res['contours']['area'], reverse=False)
self.sorted = True
if self.sorted:
for feature in sortedFeatures:
icon = QtGui.QIcon(feature['thumbnail'])
item = VideoListItem(icon, feature)
self.results.addItem(item)
def seekVideo(self, Qitem):
#Need to write a callback function to only seek once player is loaded - provide loading media graphic or progress bar
self.player.stop()
print self.player.mediaStatus()
if Qitem.feature['video'] != self.currentMedia:
self.player.setMedia(QMediaContent(QtCore.QUrl.fromLocalFile(Qitem.feature['video'])))
self.videoLoadProgress(self.player)
self.currentMedia = Qitem.feature['video']
else:
self.videoLoaded = True
if self.videoLoaded:
self.player.setPosition(Qitem.feature['milliseconds'])
self.player.play()
else:
#set up progress bar here, or loading text
def videoLoadProgress(self, QMediaPlayerObject):
self.videoStatus = VideoLoadStatus(QMediaPlayerObject)
self.videoStatus.videoLoaded.connect(self.getVideoStatus)
def getVideoStatus(self, status):
self.status = status
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoItem = QGraphicsVideoItem()
self.videoItem.setSize(QSizeF(640, 480))
scene = QGraphicsScene(self)
graphicsView = QGraphicsView(scene)
scene.addItem(self.videoItem)
rotateSlider = QSlider(Qt.Horizontal)
rotateSlider.setRange(-180, 180)
rotateSlider.setValue(0)
rotateSlider.valueChanged.connect(self.rotateVideo)
openButton = QPushButton("Open...")
openButton.clicked.connect(self.openFile)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(graphicsView)
layout.addWidget(rotateSlider)
layout.addLayout(controlLayout)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(self.videoItem)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
def sizeHint(self):
return QSize(800, 600)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def rotateVideo(self, angle):
x = self.videoItem.boundingRect().width() / 2.0
y = self.videoItem.boundingRect().height() / 2.0
self.videoItem.setTransform(
QTransform().translate(x, y).rotate(angle).translate(-x, -y))
class GameWindow(QWidget):
def open_file(self, file_name):
if file_name != "":
url = QUrl()
self.media_player.setMedia(QMediaContent(url.fromLocalFile(file_name)))
def play(self):
if self.media_player.state() == QMediaPlayer.PlayingState:
self.media_player.pause()
else:
self.media_player.play()
def play_v(self, file, rate, visibility, string=""):
self.position = 0
self.startPos = 0
self.duration = 0
self.durChanged = False
self.stopPos = False
self.open_file(file)
self.media_player.setPlaybackRate(rate)
if visibility:
self.media_player.setVolume(100)
self.video_widget.show()
self.string_label.show()
self.string_label.setText(string)
else:
self.media_player.setVolume(0)
self.video_widget.hide()
self.play()
def closeEvent(self, event):
event.ignore()
self.media_player.stop()
self.hide()
def position_changed(self, pos):
self.position = pos
if not self.durChanged and self.position > 0:
self.duration_changed(self.media_player.duration())
self.durChanged = True
if self.startPos > 0 and not self.stopPos and not self.video_widget.isVisible():
if self.position > self.startPos + 20000:
self.play()
self.stopPos = True
def duration_changed(self, dur):
self.duration = dur
if self.duration > 40000 and not self.video_widget.isVisible():
self.startPos = random.randint(5000, self.duration - 25000)
self.media_player.setPosition(self.startPos)
self.media_player.setVolume(100)
def show_string(self, string):
self.video_widget.hide()
self.string_label.show()
self.string_label.setText(string)
def open_close_window(self):
if self.isVisible():
self.hide()
else:
self.show()
def __init__(self, parent=None):
super(GameWindow, self).__init__(parent)
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.video_widget = QVideoWidget()
self.video_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.media_player.setVideoOutput(self.video_widget)
self.string_label = QLabel()
self.string_label.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.string_label.setTextFormat(Qt.RichText)
self.string_label.setAlignment(Qt.AlignHCenter)
self.string_label.setWordWrap(1)
layout = QVBoxLayout()
layout.addWidget(self.video_widget)
layout.addWidget(self.string_label)
self.setLayout(layout)
self.media_player.positionChanged.connect(self.position_changed)
self.resize(640, 480)
self.setWindowTitle("Game")
class VideoPlayer(QWidget):
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
videoWidget = QVideoWidget()
openButton = QPushButton("Open...")
openButton.clicked.connect(self.openFile)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.errorLabel = QLabel()
self.errorLabel.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(videoWidget)
layout.addLayout(controlLayout)
layout.addWidget(self.errorLabel)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(videoWidget)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.error.connect(self.handleError)
def openFile(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie",
QDir.homePath())
if fileName != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
self.playButton.setEnabled(True)
def play(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPause))
else:
self.playButton.setIcon(
self.style().standardIcon(QStyle.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
class Player(QGraphicsVideoItem):
isSubtitle = pyqtSignal(bool)
subtitlePos = pyqtSignal(int)
def __init__(self, parent=None):
super().__init__()
self.parent = parent
self.player = QMediaPlayer()
self.player.setVolume(int(settings().value("Player/volume") or 100))
self.player.setVideoOutput(self)
self.timer = QTimer(self)
self.timer.timeout.connect(self.timerPos)
self.player.currentMediaChanged.connect(self.signalStart)
self.player.currentMediaChanged.connect(self.parent.subtitleitem.subtitleControl)
self.player.currentMediaChanged.connect(self.videoConfigure)
"""self.player.mediaStatusChanged.connect(self.metadata)
def metadata(self, data):
if data and self.player.isMetaDataAvailable():
print(self.player.metaData("VideoCodec"))"""
def videoConfigure(self, media):
video_name = os.path.basename(media.canonicalUrl().toLocalFile())
videos = settings().value("Player/video_names") or []
videos_time = settings().value("Player/videos_time") or []
try:
self.player.setPosition(int(videos_time[videos.index(video_name)]))
except ValueError:
pass
def timerStart(self):
self.timer.start(200)
def signalStart(self, content):
srt = content.canonicalUrl().toLocalFile().split(".")
srt.pop(-1)
srt.append("srt")
srt = ".".join(srt)
if QFile.exists(srt):
self.isSubtitle.emit(True)
self.timer.start(100)
else:
self.isSubtitle.emit(False)
self.timer.stop()
def timerPos(self):
self.subtitlePos.emit(self.player.position())
def playerPlayOrOpen(self, arg=None):
if type(arg) == list and len(arg) > 1:
content = QMediaContent(QUrl.fromLocalFile(arg[1]))
self.player.setMedia(content)
self.play()
def addVideo(self, video):
content = QMediaContent(QUrl.fromLocalFile(video))
self.player.setMedia(content)
self.play()
def addYoutubeVideo(self, video):
dm = DownloadManager(self)
content = QMediaContent(dm.addUrl(video))
self.player.setMedia(content)
self.play()
def sliderChanged(self, pos):
self.player.setPosition(pos)
def play(self):
self.player.play()
def stop(self):
self.player.stop()
def pause(self):
self.player.pause()
def setMuted(self, mute):
self.player.setMuted(mute)
def mutedState(self):
if self.player.isMuted():
self.setMuted(False)
else:
self.setMuted(True)
def isMuted(self):
return self.player.isMuted()
def setVolume(self, value):
self.player.setVolume(value)
def volume(self):
return self.player.volume()
class Player(QWidget):
fullScreenChanged = pyqtSignal(bool)
def __init__(self, playlist, parent=None):
super(Player, self).__init__(parent)
self.colorDialog = None
self.trackInfo = ""
self.statusInfo = ""
self.duration = 0
self.player = QMediaPlayer()
self.playlist = QMediaPlaylist()
self.player.setPlaylist(self.playlist)
self.player.durationChanged.connect(self.durationChanged)
self.player.positionChanged.connect(self.positionChanged)
self.player.metaDataChanged.connect(self.metaDataChanged)
self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
self.player.mediaStatusChanged.connect(self.statusChanged)
self.player.bufferStatusChanged.connect(self.bufferingProgress)
self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
self.player.error.connect(self.displayErrorMessage)
self.videoWidget = VideoWidget()
self.player.setVideoOutput(self.videoWidget)
self.playlistModel = PlaylistModel()
self.playlistModel.setPlaylist(self.playlist)
self.playlistView = QListView()
self.playlistView.setModel(self.playlistModel)
self.playlistView.setCurrentIndex(
self.playlistModel.index(self.playlist.currentIndex(), 0))
self.playlistView.activated.connect(self.jump)
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(0, self.player.duration() / 1000)
self.labelDuration = QLabel()
self.slider.sliderMoved.connect(self.seek)
self.labelHistogram = QLabel()
self.labelHistogram.setText("Histogram:")
self.histogram = HistogramWidget()
histogramLayout = QHBoxLayout()
histogramLayout.addWidget(self.labelHistogram)
histogramLayout.addWidget(self.histogram, 1)
self.probe = QVideoProbe()
self.probe.videoFrameProbed.connect(self.histogram.processFrame)
self.probe.setSource(self.player)
openButton = QPushButton("Open", clicked=self.open)
controls = PlayerControls()
controls.setState(self.player.state())
controls.setVolume(self.player.volume())
controls.setMuted(controls.isMuted())
controls.play.connect(self.player.play)
controls.pause.connect(self.player.pause)
controls.stop.connect(self.player.stop)
controls.next.connect(self.playlist.next)
controls.previous.connect(self.previousClicked)
controls.changeVolume.connect(self.player.setVolume)
controls.changeMuting.connect(self.player.setMuted)
controls.changeRate.connect(self.player.setPlaybackRate)
controls.stop.connect(self.videoWidget.update)
self.player.stateChanged.connect(controls.setState)
self.player.volumeChanged.connect(controls.setVolume)
self.player.mutedChanged.connect(controls.setMuted)
self.fullScreenButton = QPushButton("FullScreen")
self.fullScreenButton.setCheckable(True)
self.colorButton = QPushButton("Color Options...")
self.colorButton.setEnabled(False)
self.colorButton.clicked.connect(self.showColorDialog)
displayLayout = QHBoxLayout()
displayLayout.addWidget(self.videoWidget, 2)
displayLayout.addWidget(self.playlistView)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addStretch(1)
controlLayout.addWidget(controls)
controlLayout.addStretch(1)
controlLayout.addWidget(self.fullScreenButton)
controlLayout.addWidget(self.colorButton)
layout = QVBoxLayout()
layout.addLayout(displayLayout)
hLayout = QHBoxLayout()
hLayout.addWidget(self.slider)
hLayout.addWidget(self.labelDuration)
layout.addLayout(hLayout)
layout.addLayout(controlLayout)
layout.addLayout(histogramLayout)
self.setLayout(layout)
if not self.player.isAvailable():
QMessageBox.warning(self, "Service not available",
"The QMediaPlayer object does not have a valid service.\n"
"Please check the media service plugins are installed.")
controls.setEnabled(False)
self.playlistView.setEnabled(False)
openButton.setEnabled(False)
self.colorButton.setEnabled(False)
self.fullScreenButton.setEnabled(False)
self.metaDataChanged()
self.addToPlaylist(playlist)
def open(self):
fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files")
self.addToPlaylist(fileNames)
def addToPlaylist(self, fileNames):
for name in fileNames:
fileInfo = QFileInfo(name)
if fileInfo.exists():
url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
if fileInfo.suffix().lower() == 'm3u':
self.playlist.load(url)
else:
self.playlist.addMedia(QMediaContent(url))
else:
url = QUrl(name)
if url.isValid():
self.playlist.addMedia(QMediaContent(url))
def durationChanged(self, duration):
duration /= 1000
self.duration = duration
self.slider.setMaximum(duration)
def positionChanged(self, progress):
progress /= 1000
if not self.slider.isSliderDown():
self.slider.setValue(progress)
self.updateDurationInfo(progress)
def metaDataChanged(self):
if self.player.isMetaDataAvailable():
self.setTrackInfo("%s - %s" % (
self.player.metaData(QMediaMetaData.AlbumArtist),
self.player.metaData(QMediaMetaData.Title)))
def previousClicked(self):
# Go to the previous track if we are within the first 5 seconds of
# playback. Otherwise, seek to the beginning.
if self.player.position() <= 5000:
self.playlist.previous()
else:
self.player.setPosition(0)
def jump(self, index):
if index.isValid():
self.playlist.setCurrentIndex(index.row())
self.player.play()
def playlistPositionChanged(self, position):
self.playlistView.setCurrentIndex(
self.playlistModel.index(position, 0))
def seek(self, seconds):
self.player.setPosition(seconds * 1000)
def statusChanged(self, status):
self.handleCursor(status)
if status == QMediaPlayer.LoadingMedia:
self.setStatusInfo("Loading...")
elif status == QMediaPlayer.StalledMedia:
self.setStatusInfo("Media Stalled")
elif status == QMediaPlayer.EndOfMedia:
QApplication.alert(self)
elif status == QMediaPlayer.InvalidMedia:
self.displayErrorMessage()
else:
self.setStatusInfo("")
def handleCursor(self, status):
if status in (QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia, QMediaPlayer.StalledMedia):
self.setCursor(Qt.BusyCursor)
else:
self.unsetCursor()
def bufferingProgress(self, progress):
self.setStatusInfo("Buffering %d%" % progress)
def videoAvailableChanged(self, available):
if available:
self.fullScreenButton.clicked.connect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.connect(
self.fullScreenButton.setChecked)
if self.fullScreenButton.isChecked():
self.videoWidget.setFullScreen(True)
else:
self.fullScreenButton.clicked.disconnect(
self.videoWidget.setFullScreen)
self.videoWidget.fullScreenChanged.disconnect(
self.fullScreenButton.setChecked)
self.videoWidget.setFullScreen(False)
self.colorButton.setEnabled(available)
def setTrackInfo(self, info):
self.trackInfo = info
if self.statusInfo != "":
self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def setStatusInfo(self, info):
self.statusInfo = info
if self.statusInfo != "":
self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
else:
self.setWindowTitle(self.trackInfo)
def displayErrorMessage(self):
self.setStatusInfo(self.player.errorString())
def updateDurationInfo(self, currentInfo):
duration = self.duration
if currentInfo or duration:
currentTime = QTime((currentInfo/3600)%60, (currentInfo/60)%60,
currentInfo%60, (currentInfo*1000)%1000)
totalTime = QTime((duration/3600)%60, (duration/60)%60,
duration%60, (duration*1000)%1000);
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
tStr = currentTime.toString(format) + " / " + totalTime.toString(format)
else:
tStr = ""
self.labelDuration.setText(tStr)
def showColorDialog(self):
if self.colorDialog is None:
brightnessSlider = QSlider(Qt.Horizontal)
brightnessSlider.setRange(-100, 100)
brightnessSlider.setValue(self.videoWidget.brightness())
brightnessSlider.sliderMoved.connect(
self.videoWidget.setBrightness)
self.videoWidget.brightnessChanged.connect(
brightnessSlider.setValue)
contrastSlider = QSlider(Qt.Horizontal)
contrastSlider.setRange(-100, 100)
contrastSlider.setValue(self.videoWidget.contrast())
contrastSlider.sliderMoved.connect(self.videoWidget.setContrast)
self.videoWidget.contrastChanged.connect(contrastSlider.setValue)
hueSlider = QSlider(Qt.Horizontal)
hueSlider.setRange(-100, 100)
hueSlider.setValue(self.videoWidget.hue())
hueSlider.sliderMoved.connect(self.videoWidget.setHue)
self.videoWidget.hueChanged.connect(hueSlider.setValue)
saturationSlider = QSlider(Qt.Horizontal)
saturationSlider.setRange(-100, 100)
saturationSlider.setValue(self.videoWidget.saturation())
saturationSlider.sliderMoved.connect(
self.videoWidget.setSaturation)
self.videoWidget.saturationChanged.connect(
saturationSlider.setValue)
layout = QFormLayout()
layout.addRow("Brightness", brightnessSlider)
layout.addRow("Contrast", contrastSlider)
layout.addRow("Hue", hueSlider)
layout.addRow("Saturation", saturationSlider)
button = QPushButton("Close")
layout.addRow(button)
self.colorDialog = QDialog(self)
self.colorDialog.setWindowTitle("Color Options")
self.colorDialog.setLayout(layout)
button.clicked.connect(self.colorDialog.close)
self.colorDialog.show()
