class VideoPlayer(QMediaPlayer):
"""docstring for VideoPlayer"""
def __init__(self):
super(VideoPlayer, self).__init__(None, QMediaPlayer.VideoSurface)
self.view = QVideoWidget()
self.view.setWindowTitle('Video Player')
self.setVideoOutput(self.view)
def widget(self):
return self.view
def show(self):
self.view.show()
def hide(self):
self.view.hide()
def isVisible(self):
return self.view.isVisible()
def setSize(self, width, height):
self.view.resize(width, height)
def toggle(self):
if self.state() == self.PlayingState:
self.pause()
else:
self.play()
def loadMedia(self, fullPath):
self.setMedia(QMediaContent(QUrl.fromLocalFile(fullPath)))
self.stop()
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
def video_init(self):
videoWidget = QVideoWidget(self.ui.widget_video)
videoWidget.setObjectName("videoWidget")
videoWidget.setAutoFillBackground(True)
videoWidget.setAspectRatioMode(Qt.IgnoreAspectRatio)
videoWidget.setContentsMargins(0, 0, 0, 0)
videoWidget.show()
self.player = QMediaPlayer(videoWidget)
self.player.setVolume(100)
self.player.setVideoOutput(videoWidget)
srcList = self.get_video()
self.CheckPlayList()
time.sleep(2)
self.update()
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 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("D:/FILM/film/data/video/2.mp4")))
self.timer = QTimer()
self.timer.timeout.connect(self.check)
self.timer.start(1000)
def callback(self):
self.player.setPosition(0) # to start at the beginning of the video every time
self.video.show()
self.player.play()
def check(self):
print('DADA')
def loose(self):
if globals.loose_animation:
video = QVideoWidget()
video.resize(500, 400)
video.setWindowTitle("GAME OVER")
player = QMediaPlayer()
player.setVideoOutput(video)
player.setMedia(
QMediaContent(QUrl.fromLocalFile("../Video/bum.gif")))
video.show()
player.play()
self.signals.add_music.emit()
time.sleep(5.5)
self.signals.delete_music.emit()
player.stop()
video.close()
else:
__loose_statement = QMessageBox.question(
QMessageBox(), "GAME OVER!!",
"You loose!!!\nYour time: {}".format(globals.time),
QMessageBox.Ok)
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 Example(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.startTimeValue=0
self.endTimeValue=0
self.fpsValue=1
# 视频预览
self.player = QMediaPlayer(self)
self.vw= QVideoWidget(self) # 定义视频显示的widget
self.vw.setGeometry(20,20,600,600)
self.vw.show()
self.player.setVideoOutput(self.vw) # 视频播放输出的widget，就是上面定义的
self.player.positionChanged.connect(self.changeSlide)
# 播放按钮
self.btn = QPushButton('play', self)
self.btn.move(20, 620)
self.btn.clicked.connect(self.player.play)
# 暂停按钮
self.btn = QPushButton('pause', self)
self.btn.move(120, 620)
self.btn.clicked.connect(self.player.pause)
# 停止按钮
self.btn = QPushButton('stop', self)
self.btn.move(220, 620)
self.btn.clicked.connect(self.player.stop)
# 播放时长
self.videoPlayDurationLabel = QLabel(self)
self.videoPlayDurationLabel.setGeometry(320, 620, 100, 40)
# 开始转换准备
# 分辨率
self.startLabel = QLabel(self)
self.startLabel.setGeometry(640, 10, 260, 40)
self.startLabel.setText('分辨率：默认尺寸(暂不支持变更)')
# 开始时间
self.startLabel = QLabel(self)
self.startLabel.setGeometry(640, 40, 50, 40)
self.startLabel.setText('start:')
# 开始时间值
startTimeValueLE = QLineEdit(self)
startTimeValueLE.move(680, 40)
startTimeValueLE.textChanged[str].connect(self.onChangedOfStartTime)
startTimeValueLE.setText(str(self.startTimeValue))
# 结束时间
self.startLabel = QLabel(self)
self.startLabel.setGeometry(640, 80, 50, 40)
self.startLabel.setText('end:')
self.endTimeValueLE = QLineEdit(self)
self.endTimeValueLE.move(680, 80)
self.endTimeValueLE.textChanged[str].connect(self.onChangedOfEndTime)
self.endTimeValueLE.setText(str(self.endTimeValue))
# FPS
self.fpsLabel = QLabel(self)
self.fpsLabel.setGeometry(640, 120, 50, 40)
self.fpsLabel.setText('fps:')
fpsValueLE = QLineEdit(self)
fpsValueLE.move(680, 120)
fpsValueLE.textChanged[str].connect(self.onChangedOfFPS)
fpsValueLE.setText(str(self.fpsValue))
# 转换
self.btn = QPushButton('转换gif', self)
self.btn.move(640, 160)
self.btn.clicked.connect(self.transformToGif)
# gif的文件名称
self.gifFileNameLable=QLabel(self)
self.gifFileNameLable.setGeometry(640, 190, 200, 60)
# self.gifFileNameLable.setText('xxxx.gif')
# Gif的文件大小
self.gifSizeLable=QLabel(self)
self.gifSizeLable.move(640,230)
# self.gifSizeLable.setText('0KB')
# 导出
#预览
# self.pbar = QProgressBar(self)
# self.pbar.setGeometry(30, 100, 200, 25)
openFile = QAction(QIcon('open.png'), 'Open', self)
openFile.setShortcut('Ctrl+O')
openFile.setStatusTip('Open new File')
openFile.triggered.connect(self.showDialog)
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(openFile)
self.label = QLabel(self)
self.label.setGeometry(800, 20, 400, 500)
self.label.setScaledContents(True)
self.setGeometry(0, 0, 1300, 900)
self.setWindowTitle('视频转Gif动图')
self.show()
def changeSlide(self, position):
self.vidoeLength = self.player.duration() + 0.1
print(self.vidoeLength)
# self.sld_video.setValue(round((position / self.vidoeLength) * 100))
self.videoPlayDurationLabel.setText(str(round((position / self.vidoeLength) * 100, 2)) + '%')
if((self.endTimeValue)==0):
self.endTimeValueLE.setText(str(int(self.player.duration()/1000)))
def transformToGif(self):
print('transformToGif--filepath='+fileList[0].path())
cache = mpe.VideoFileClip(fileList[0].path()).subclip(self.startTimeValue,self.endTimeValue)
date=time.strftime('%Y-%m-%d_%H-%M-%S')
resultGifFilePath='./gif/'+date+'.gif'# 使用日期时间作为gif文件名称
# TODO 转换进度条对话框 展示
cache.write_gif(resultGifFilePath,fps=float(self.fpsValue))
self.gif = QMovie(resultGifFilePath)
self.label.setMovie(self.gif)
self.gif.start()
self.gifFileNameLable.setText(date+'.gif')
doubleSize=os.path.getsize(resultGifFilePath)/1000
self.gifSizeLable.setText(str(int(doubleSize))+'KB')
def onChangedOfFPS(self, text):
self.fpsValue=text
print('fps='+self.fpsValue)
def onChangedOfStartTime(self, text):
self.startTimeValue=text
print('起点 start='+self.startTimeValue)
def onChangedOfEndTime(self, text):
if(''==text):
self.endTimeValue=-1
else :
self.endTimeValue=int(text)
print('end='+ str(self.endTimeValue))
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step = self.step + 1
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
# def changeValue(self, value):
# if value == 0:
# self.label.setPixmap(QPixmap('./gif/2022-03-21-17.19.44.gif'))
# elif value > 0 and value <= 30:
# self.label.setPixmap(QPixmap('./img/1.jpg'))
# elif value > 30 and value < 80:
# self.label.setPixmap(QPixmap('med.ico'))
# else:
# self.label.setPixmap(QPixmap('max.ico'))
def showDialog(self):
# TODO 视频文件大小
# TODO 播放时长
# TODO 视频播放总时长显示
global fileList
fileList = QFileDialog.getOpenFileUrl()
print(fileList[0])
self.player.setMedia(QMediaContent(fileList[0])) # 选取视频文件
self.player.play()
def closeEvent(self, event):
reply = QMessageBox.question(self, 'Message',
"Are you sure to quit?", QMessageBox.Yes |
QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
event.accept()
else:
event.ignore()
else:
break
# realising when video is done and closing all windows
cap.release()
cv2.destroyAllWindows()
detectorThread = threading.Thread(target=detectorMethod)
timerThread = threading.Thread(target=timerCheck)
if __name__ == "__main__":
app = QApplication(sys.argv)
player = QMediaPlayer()
wgt_video = QVideoWidget() # Video display widget
wgt_video.show()
player.setVideoOutput(wgt_video) # widget for video output
player.setMedia(QMediaContent(
QFileDialog.getOpenFileUrl()[0])) # Select video file
while True:
try:
webcam = int(input("enter camera input: "))
break
except:
print("only numbers")
cap = cv2.VideoCapture(webcam)
cv2.imshow('window', cv2.imread('images/Smile_detection_intro3.png'))
while True:
class MyForm(QMainWindow):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.lineEdit.textChanged.connect(self.aramaMetniDegistir)
self.ui.listWidget.itemClicked.connect(self.listedeKiElemanSecildi)
self.ui.comboBox.activated.connect(self.comboBoxTiklama)
self.ui.actionKategori_Ekle.triggered.connect(self.yeniKategoriEkle)
self.ui.actionKategori_Sil.triggered.connect(self.kategoriSil)
self.ui.actionKategori_Duzenle.triggered.connect(self.kategoriDuzenle)
self.ui.actionCoktanSecmeliSinav.triggered.connect(self.sinavCoktanSecmeli)
self.ui.actionHafizaOyunu.triggered.connect(self.hafizaOyunuAc)
self.ui.actionHafizaOyunu2.triggered.connect(self.hafizaOyunuAc2)
self.ui.actionKisaCevap.triggered.connect(self.kisacevapOyunuAc)
self.ui.actionYardim.triggered.connect(self.Yardim)
self.ui.actionHakkinda.triggered.connect(self.Hakkinda)
self.ui.actionKelime_Ekle.triggered.connect(self.yeniKelimeEkle)
self.ui.actionKelime_Sil.triggered.connect(self.kelimeSil)
self.ui.actionKelime_Duzenle.triggered.connect(self.kelimeDuzenle)
self.secilenKelime = Kelime()
self.secilenKategori = Kategori()
self.yeniKategori = Kategori()
self.silinecekKategori = Kategori()
self.kelimeListesi = []
self.kategoriListesi = []
self.seciliListe = []
self.listeleriHazirla()
self.listeyiHazirla()
self.comboListeHazirla()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
self.buton = KayitButonu(self)
self.buton.setIcon(QIcon('micro.png'))
self.buton.setIconSize(QSize(40, 40))
self.buton.setGeometry(0, 0, 50, 50)
self.buton.setStyleSheet('border-radius:60')
self.buton.setCursor(QCursor(Qt.PointingHandCursor))
self.buton.setFixedSize(self.buton.size())
self.buton.setEnabled(True)
self.buton.clicked.connect(self.butonTiklandi)
self.progress = QProgressBar(self, minimum=0, maximum=0, objectName="RedProgressBar")
self.progress.setGeometry(0, 0, 300, 25)
self.progress.setMaximum(5)
self.progress.setFormat('')
self.progress.setStyleSheet("#RedProgressBar::chunk {"
"background-color: #F44336;"
"}")
hBox = QHBoxLayout()
hBox.setContentsMargins(0, 0, 0, 0)
hBox.addWidget(self.buton)
hBox.setAlignment(Qt.AlignHCenter)
hBox2 = QHBoxLayout()
hBox2.setContentsMargins(0, 0, 0, 0)
hBox2.addWidget(self.progress)
hBox2.setAlignment(Qt.AlignHCenter)
hBox3 = QHBoxLayout()
hBox3.setContentsMargins(0, 2, 0, 2)
hBox3.setAlignment(Qt.AlignHCenter)
vBoxLayout = QVBoxLayout()
vBoxLayout.addLayout(hBox)
vBoxLayout.addLayout(hBox2)
vBoxLayout.addLayout(hBox3)
vBoxLayout.addWidget(self.videoWidget)
self.ui.layout.addLayout(vBoxLayout)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile("VIDEOLAR\MERHABA.mp4")))
self.progress.hide()
self.videoWidget.show()
self.mediaPlayer.play()
self.videoWidget.show()
self.show()
def recognize_speech_from_mic(self, recognizer, microphone):
if not isinstance(recognizer, sr.Recognizer):
raise TypeError("`recognizer` must be `Recognizer` instance")
if not isinstance(microphone, sr.Microphone):
print('HATA 2')
raise TypeError("`microphone` must be `Microphone` instance")
response = {"success": True, "error": None, "transcription": None}
try:
with microphone as source:
recognizer.adjust_for_ambient_noise(source)
audio = recognizer.listen(source, timeout=4)
except sr.WaitTimeoutError:
response["error"] = "Zamanında kelime söylemediniz."
# self.uyariLbl.setText(response["error"])
# self.uyariLbl.show()
self.buton.setIcon(QIcon('micro.png'))
except:
print("Bir şeyler ters gitti. Tekrar deneyin.")
# self.uyariLbl.show()
self.buton.setIcon(QIcon('micro.png'))
else:
try:
response["transcription"] = recognizer.recognize_google(audio, language='tr')
except sr.RequestError:
response["success"] = False
response["error"] = "API hatası! Arayüze ulaşılamadı."
# self.uyariLbl.setText(response["error"])
# self.uyariLbl.show()
except sr.UnknownValueError:
response["error"] = "Konuşmanız anlaşılamadı."
# self.uyariLbl.setText(response["error"])
# self.uyariLbl.show()
return response
def sesleAra(self):
# self.uyariLbl.hide()
recognizer = sr.Recognizer()
microphone = sr.Microphone()
self.guess = self.recognize_speech_from_mic(recognizer, microphone)
if not self.guess["transcription"] or not self.guess["success"]:
print("anlaşılamadı")
# self.uyariLbl.show()
elif self.guess["error"]:
print(self.guess["error"])
# self.uyariLbl.show()
else:
try:
yol = seslearamavb.yolDondur(self.guess["transcription"])
self.videoyuOynat(yol)
self.ui.listWidget.clear()
self.ui.lineEdit.setText(self.guess["transcription"])
except Exception as e:
self.ui.lineEdit.setText("Sözcük Bulunamadı")
self.buton.setIcon(QIcon('micro.png'))
self.buton.setEnabled(True)
def onCountChanged(self, value):
self.progress.setValue(value)
def onButtonClick(self):
self.calc = External()
self.calc.countChanged.connect(self.onCountChanged)
self.calc.start()
def butonTiklandi(self):
self.progress.show()
thread = threading.Thread(target=self.sesleAra)
thread.start()
self.onButtonClick()
def listeleriHazirla(self):
try:
kelimeListesiTupple = KelimeBLL.KelimeleriListele()
kategoriListesiTupple = KategoriBLL.KategorileriListele()
self.kelimeListesi = [item[0] for item in kelimeListesiTupple]
self.kategoriListesi = [item[0] for item in kategoriListesiTupple]
self.kategoriListesi.insert(0, "Kategori Seçin")
except Exception as exp:
print(exp)
def yeniKelimeEkle(self):
try:
self.yenikelimeEkle = YeniKelimeEkle()
self.yenikelimeEkle.show()
if self.yenikelimeEkle.close:
print("Deneme")
except Exception as e:
print(e)
donusDurumu=self.yenikelimeEkle.exec_()
if donusDurumu== 1:
QMessageBox.information(self, "Yeni Kelime", "Yeni Kelime Eklendi")
else:
QMessageBox.warning(self, "Yeni Kelime", "Yeni kelime eklenemedi.")
self.listeleriHazirla()
self.comboListeHazirla()
self.listeyiHazirla()
def kelimeSil(self):
try:
self.kelimeSil = SilinecekKelimeForm()
self.kelimeSil.show()
except Exception as e:
print(e)
donusDurumu = self.kelimeSil.exec_()
if donusDurumu == 1:
QMessageBox.information(self, "Kelime Sil", "Kelime Silindi")
else:
QMessageBox.warning(self, "Kelime Sil", "Kelime Silinemedi.")
self.listeleriHazirla()
self.comboListeHazirla()
self.listeyiHazirla()
def kelimeDuzenle(self):
print("Kelime Düzenle menü basıldı")
try:
self.KelimeDuzenle = DuzenlenecekKelimeForm()
print("Kelime Düzenle yaratıldı")
self.KelimeDuzenle.show()
if self.KelimeDuzenle.close:
print("Kelime Düzenle Kapatıldı")
except Exception as e:
print(e)
donusDurumu= self.KelimeDuzenle.exec_()
if donusDurumu== 1:
QMessageBox.information(self, "Kelime Düzenle", "Kelime Düzeltildi.")
else:
QMessageBox.warning(self, "Kelime Düzenle", "Kelime Düzenlenemedi.")
self.listeleriHazirla()
self.comboListeHazirla()
self.listeyiHazirla()
def kategoriDuzenle(self):
try:
self.kategoriDuzenle = KategoriDuzenle()
self.kategoriDuzenle.show()
if self.kategoriDuzenle.close:
print("Deneme")
except Exception as e:
print(e)
donusDurumu = self.kategoriDuzenle.exec_()
if donusDurumu == 1:
QMessageBox.information(self, "Kategori Düzenle", "Kategori Düzenlendi.")
else:
QMessageBox.warning(self, "Kategori Düzenle", "Kategori Düzenlenemedi.")
self.listeleriHazirla()
self.comboListeHazirla()
self.listeyiHazirla()
def yeniKategoriEkle(self):
try:
self.yeniKategoriEkle = YeniKategoriEkle()
self.yeniKategoriEkle.show()
if self.yeniKategoriEkle.close:
print("Yeni Kategori Sayfası kapatıldı.")
except Exception as e:
print(e)
donusDurumu = self.yeniKategoriEkle.exec_()
if donusDurumu == 1:
QMessageBox.information(self, "Yeni Kelime", "Yeni Kelime Eklendi")
else:
QMessageBox.warning(self, "Yeni Kategori", "Yeni Kategori Eklenemedi")
self.listeleriHazirla()
self.listeyiHazirla()
self.comboListeHazirla()
def kategoriSil(self):
try:
self.kategoriSil = KategoriSil()
self.kategoriSil.show()
donusDurumu = self.kategoriSil.exec_()
if donusDurumu == 1:
QMessageBox.information(self, "Kategori Sil", "Kategori ve ilişileri Silindi")
else:
QMessageBox.warning(self, "Kategori Sil", "Kategori ve/veya ilişkileri silinemedi.")
except Exception as e:
print(e)
self.listeleriHazirla()
self.comboListeHazirla()
self.listeyiHazirla()
def comboBoxTiklama(self):
print("tıklandı")
self.secilenKategori.kategori = self.ui.comboBox.itemText(self.ui.comboBox.currentIndex())
if (self.ui.comboBox.currentIndex() != 0): # düzeltilmesi gerekiyor bütün hepsinde çıkması lazım
try:
kelimeListesi = KategoriBLL.KategoriyeAitKelimeler(self.secilenKategori)
self.ui.listWidget.clear()
self.ui.listWidget.addItems(kelimeListesi)
except Exception as e:
print(e)
else:
self.listeleriHazirla()
self.listeyiHazirla()
def comboListeHazirla(self):
self.ui.comboBox.clear()
self.ui.comboBox.addItems(self.kategoriListesi)
def listeyiHazirla(self):
self.ui.listWidget.clear()
self.ui.listWidget.addItems(self.kelimeListesi)
def videoyuOynat(self, video):
##self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile("VIDEOLAR/RAHAT.mp4")))
self.progress.hide()
self.videoWidget.show()
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(video)))
self.mediaPlayer.play()
def listedeKiElemanSecildi(self):
self.secilenKelime.kelime = self.ui.listWidget.currentItem().text()
sonuc = KelimeBLL.KelimeVideoBul(self.secilenKelime)
print(sonuc)
self.videoyuOynat(sonuc)
def sinavCoktanSecmeli(self):
self.Form = QtWidgets.QWidget()
self.Form.ui = Sinav_coktan_secme()
self.Form.ui.show()
def aramaMetniDegistir(self):
self.ui.listWidget.clear()
self.seciliListe.clear()
aramaMetni = self.ui.lineEdit.text()
for v in self.kelimeListesi:
if v.startswith(Helper.KucukHarfleriBuyukYap(aramaMetni)):
self.seciliListe.append(v)
self.ui.listWidget.addItems(self.seciliListe)
def hafizaOyunuAc(self):
h = HafizaOyunu()
h.oyunuBaslat()
def hafizaOyunuAc2(self):
h = HafizaOyunu2()
h.oyunuBaslat()
def kisacevapOyunuAc(self):
KisaCevapFrom()
def Hakkinda(self):
self.hakkinda = Hakkinda()
self.hakkinda.show()
def Yardim(self):
webbrowser.open('https://github.com/munel/is_en')
class Window(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("PyQt5 Media Player")
self.setGeometry(0, 0, 700, 600)
self.setWindowIcon(QIcon('player.png'))
p = self.palette()
p.setColor(QPalette.Window, Qt.black)
self.setPalette(p)
self.init_ui()
self.show()
self.audio_process = False
self.position = 0
self.filename = '.'
def init_ui(self):
#create media player object
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
#create videowidget object
videoHboxLayout = QHBoxLayout()
self.videowidget = QVideoWidget()
self.videowidget.setFixedHeight(300)
self.videowidget.setFixedWidth(352)
self.imagewidget = QLabel()
self.imagewidget.setFixedWidth(352)
self.imagewidget.setFixedHeight(300)
videoHboxLayout.addWidget(self.videowidget)
videoHboxLayout.addWidget(self.imagewidget)
videoHboxLayout.setContentsMargins(0, 0, 0, 0)
videoHboxLayout.setSpacing(0)
#create open button
openBtn = QPushButton('Open Video')
openBtn.clicked.connect(self.open_file)
#create button for playing
self.playBtn = QPushButton()
self.playBtn.setEnabled(False)
self.playBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playBtn.clicked.connect(self.play_video)
self.stopBtn = QPushButton()
self.stopBtn.setEnabled(False)
self.stopBtn.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
self.stopBtn.clicked.connect(self.reset_video)
#create label
self.label = QLabel()
self.label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
#create hbox layout
hboxLayout = QHBoxLayout()
hboxLayout.setContentsMargins(0, 0, 0, 0)
#set widgets to the hbox layout
hboxLayout.addWidget(openBtn)
hboxLayout.addWidget(self.playBtn)
hboxLayout.addWidget(self.stopBtn)
synopLayout = QVBoxLayout()
synopLayout.setContentsMargins(0, 0, 0, 0)
synopLayout.setSpacing(0)
self.generate_synopsis_video(synopLayout)
self.generate_synopsis_image(synopLayout)
# image1 = ClickLabel()
# pixmap = QPixmap('../test.jpg')
# image1.setPixmap(pixmap)
# image1.setFixedSize(100, 50)
#
# image1.clicked.connect(self.synopsis_click_handler)
# synopImageLayout.addWidget(image1)
#create vbox layout
vboxLayout = QVBoxLayout()
vboxLayout.addLayout(videoHboxLayout)
vboxLayout.addLayout(hboxLayout)
vboxLayout.addWidget(self.label)
vboxLayout.addLayout(synopLayout)
self.setLayout(vboxLayout)
self.mediaPlayer.setVideoOutput(self.videowidget)
pal = self.palette()
pal.setBrush(QPalette.Window, QBrush(QPixmap("../keyimages/1.png")))
self.videowidget.setPalette(pal)
#media player signals
self.mediaPlayer.stateChanged.connect(self.mediastate_changed)
self.mediaPlayer.positionChanged.connect(self.position_changed)
self.imagewidget.hide()
def generate_synopsis_video(self, synopLayout):
frame_folder = os.path.join(parent_dir, 'keyframes')
image_dir = os.listdir(frame_folder)
image_dir.remove('.gitignore')
image_dir.remove('.DS_Store')
image_dir.sort(key=lambda img: (int(img.split('_')[0][-1]) * 10000 +
int(img.split('_')[1].split('.')[0])))
images = [image for image in image_dir]
count = 0
synopImageLayout = QHBoxLayout()
synopImageLayout.setContentsMargins(0, 0, 0, 0)
synopImageLayout.setSpacing(0)
for imageName in images:
# frame_time = int(imageName.split('_')[1].split('.')[0])
video_no = int(imageName.split('_')[0][-1])
timestamp = (int(imageName.split('_')[1].split('.')[0]))
image_label = ClickLabel()
pixmap = QPixmap(os.path.join(parent_dir, 'keyframes', imageName))\
.scaled(44, 36, Qt.KeepAspectRatio, Qt.FastTransformation)
image_label.setPixmap(pixmap)
image_label.clicked.connect(lambda t=timestamp, n=video_no: self.
synopsis_click_handler(t, n))
synopImageLayout.addWidget(image_label)
count += 1
if count == 17:
synopLayout.addLayout(synopImageLayout)
synopImageLayout = QHBoxLayout()
synopImageLayout.setContentsMargins(0, 0, 0, 0)
synopImageLayout.setSpacing(0)
count = 0
def generate_synopsis_image(self, synopLayout):
image_folder = os.path.join(parent_dir, 'keyimages')
image_dir = os.listdir(image_folder)
image_dir.remove('.DS_Store')
image_dir.sort(key=lambda img: int(img.split('.')[0]))
images = [image for image in image_dir]
count = 0
rowcount = 0
synopImageLayout = QHBoxLayout()
synopImageLayout.setContentsMargins(0, 0, 0, 0)
synopImageLayout.setSpacing(0)
for imageName in images:
image_no = int(imageName.split('.')[0])
image_label = ClickLabel()
pixmap = QPixmap(os.path.join(image_folder, imageName)) \
.scaled(44, 36, Qt.KeepAspectRatio, Qt.FastTransformation)
image_label.setPixmap(pixmap)
image_label.clicked.connect(
lambda filename=os.path.join(image_folder, imageName): self.
image_synopsis_click_handler(filename))
synopImageLayout.addWidget(image_label)
count += 1
if count == 17:
synopLayout.addLayout(synopImageLayout)
rowcount += 1
if rowcount > 3:
return
synopImageLayout = QHBoxLayout()
synopImageLayout.setContentsMargins(0, 0, 0, 0)
synopImageLayout.setSpacing(0)
count = 0
def open_video_file(self, filename):
path = os.path.join(parent_dir, 'videos')
mp4_path = os.path.join(path, 'mp4')
avi_path = os.path.join(path, 'avi')
mp4_name = filename + '.mp4'
avi_name = filename + '.avi'
mp4_dir = os.listdir(mp4_path)
for mp4 in mp4_dir:
if mp4_name == mp4:
self.mediaPlayer.setMedia(
QMediaContent(
QUrl.fromLocalFile(os.path.join(mp4_path, mp4_name))))
self.stopBtn.setEnabled(True)
self.playBtn.setEnabled(True)
self.filename = mp4_name
return
convert_avi_to_mp4(os.path.join(avi_path, avi_name),
os.path.join(mp4_path, mp4_name))
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(os.path.join(mp4_path,
mp4_name))))
self.playBtn.setEnabled(True)
self.stopBtn.setEnabled(True)
self.filename = mp4_name
def open_file(self):
filename, _ = QFileDialog.getOpenFileName(self, "Open Video")
if os.path.splitext(filename)[1] == '.avi':
output_name = os.path.dirname(filename) + '/output.mp4'
convert_avi_to_mp4(filename, output_name)
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(output_name)))
self.playBtn.setEnabled(True)
elif filename != '':
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(filename)))
self.playBtn.setEnabled(True)
def play_video(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
if self.audio_process:
self.audio_process.kill()
self.audio_process = False
else:
self.mediaPlayer.play()
self.create_audio_process(
'../videos/{filename}/audio.wav'.format(
filename=self.filename.split('.')[0]),
self.position / 1000)
def reset_video(self):
self.mediaPlayer.pause()
self.mediaPlayer.setPosition(0)
if self.audio_process:
self.audio_process.kill()
self.audio_process = False
def mediastate_changed(self, state):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPause))
else:
self.playBtn.setIcon(self.style().standardIcon(
QStyle.SP_MediaPlay))
def create_audio_process(self, filename, start_time):
if self.audio_process:
self.audio_process.kill()
cmd = "python3 audio.py {filename} {start}".format(filename=filename,
start=start_time)
self.audio_process = subprocess.Popen(cmd, shell=True)
def position_changed(self, position):
self.position = position
def duration_changed(self, duration):
self.slider.setRange(0, duration)
def set_position(self, position):
self.play_video()
self.mediaPlayer.setPosition(position)
def handle_errors(self):
self.playBtn.setEnabled(False)
self.label.setText("Error: " + self.mediaPlayer.errorString())
def stop_video(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.play_video()
def image_synopsis_click_handler(self, filename):
self.imagewidget.show()
self.videowidget.hide()
self.stop_video()
self.playBtn.setEnabled(False)
self.stopBtn.setEnabled(False)
pixmap = QPixmap(filename)
self.imagewidget.setPixmap(pixmap)
def synopsis_click_handler(self, frame, video_no):
self.imagewidget.hide()
self.videowidget.show()
self.playBtn.setEnabled(True)
self.stopBtn.setEnabled(True)
new_filename = 'video' + str(video_no)
if self.filename.split('.')[0] != new_filename:
self.open_video_file(new_filename)
time = frame / 30 * 1000
self.mediaPlayer.setPosition(time)
self.position = time
self.stop_video()
# Create a place to show a thumbnail of the last meal
lastMealImageLabel = QLabel()
#lastMealImage = None#QtGui.QPixmap('TestImage.jpeg')
lastMealImageLabel.setScaledContents(True)
#lastMealImageLabel.setPixmap(lastMealImage)
grid.addWidget(lastMealImageLabel, 0, 1)
lastMealImageLabel.show()
# Create a place to show video of the last Meal
mediaPlayer = QMediaPlayer()
mediaPlaylist = QMediaPlaylist(mediaPlayer)
videoWidget = QVideoWidget()
mediaPlayer.setPlaylist(mediaPlaylist)
mediaPlayer.setVideoOutput(videoWidget)
videoWidget.show()
grid.addWidget(videoWidget, 1, 1, 2, 1)
# Create a button to pull up the video of the last meal
mealLog = MealLog("log.txt")
mealSelector = QComboBox()
mealSelector.addItems(mealLog.getMeals())
def mealSelected(selectedMeal):
meal = mealLog.getMeal(selectedMeal)
mediaPlaylist.clear()
videoFilePath = QFileInfo("MealVideos/{0}".format(
meal.getVideoFileName())).absoluteFilePath()
mediaPlaylist.addMedia(QMediaContent(QUrl.fromLocalFile(videoFilePath)))
mediaPlaylist.setPlaybackMode(QMediaPlaylist.Loop)
class Ui_ShadowRCNN(QWidget):
def login(self, Dialog):
self.login_dialog = login.Ui_Dialog()
self.login_dialog.setupUi(Dialog)
self.login_dialog.pushButton.clicked.connect(
lambda: self.login_operation(Dialog))
self.login_dialog.toolButton.clicked.connect(self.open_path)
def open_path(self):
param_path, _ = QFileDialog.getOpenFileName(QWidget(), "选择文件",
"../param",
"*.pth;;;All Files(*)")
if param_path != '':
self.login_dialog.lineEdit_3.setText(param_path)
######TODO 自定义参数的数据库连接
def login_operation(self, Dialog):
global RCNN_PATH
success = False
error = ''
self.is_guest = False
self.user_name = 'guest'
self.user_id = -1
self.param_id = 1
if self.login_dialog.radioButton_2.isChecked():
self.is_guest = True
self.user_name = '游客'
success = True
if self.login_dialog.radioButton.isChecked():
username = self.login_dialog.lineEdit.text()
password = self.login_dialog.lineEdit_2.text()
if username.strip() == '' or password.strip() == '':
error = 'blank'
else:
results = db_select('select * from tb_user')
for result in results:
if username == result[1]:
if password == result[2]:
self.user_name = username
self.user_id = result[0]
success = True
break
else:
error = 'wrong'
break
if not success and error == '':
sql = 'insert into tb_user(username, password)values("%s", "%s")' % (
username, password)
db_insert(sql)
msg = QMessageBox.information(self, '提示',
'已为您自动注册用户名%s' % username,
QMessageBox.Ok,
QMessageBox.Ok)
self.user_name = username
sql = 'select * from tb_user order by user_id desc limit 1'
results = db_select(sql)
for result in results:
self.user_id = result[0]
print(self.user_id)
success = True
if success:
global IMAGE_PATH
global VIDEO_PATH
IMAGE_PATH = os.path.join(IMAGE_PATH, self.user_name)
VIDEO_PATH = os.path.join(VIDEO_PATH, self.user_name)
if not os.path.exists(IMAGE_PATH):
os.makedirs(IMAGE_PATH)
if not os.path.exists(VIDEO_PATH):
os.makedirs(VIDEO_PATH)
if self.login_dialog.lineEdit_3.text() != '默认参数':
RCNN_PATH = self.login_dialog.lineEdit_3.text()
Dialog.close()
self.main_window = QMainWindow()
self.setupUi(self.main_window)
self.main_window.show()
else:
if error == 'blank':
msg = QMessageBox.warning(self, '提示', '请输入正确的用户名与密码！',
QMessageBox.Ok, QMessageBox.Ok)
elif error == 'wrong':
msg = QMessageBox.warning(self, '提示', '用户名或密码错误！',
QMessageBox.Ok, QMessageBox.Ok)
def setupUi(self, ShadowRCNN):
ShadowRCNN.setObjectName("ShadowRCNN")
ShadowRCNN.resize(1666, 900)
self.centralwidget = QtWidgets.QWidget(ShadowRCNN)
self.centralwidget.setObjectName("centralwidget")
self.label = QtWidgets.QLabel(self.centralwidget)
self.label.setGeometry(QtCore.QRect(190, 40, 1280, 720))
self.label.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor))
self.label.setAlignment(QtCore.Qt.AlignCenter)
self.label.setObjectName("label")
self.label.setStyleSheet(
"QLabel{background:white;}"
"QLabel{color:rgb(300,300,300,120);font-size:20px;font-weight:bold;}"
)
self.label_name = QtWidgets.QLabel(self.centralwidget)
self.label_name.setGeometry(QtCore.QRect(10, 5, 200, 40))
self.label_name.setCursor(QtGui.QCursor(QtCore.Qt.ArrowCursor))
self.label_name.setObjectName("label")
self.label_name.setStyleSheet(
"QLabel{color:rgb(300,300,300,120);font-size:20px;font-weight:bold;}"
)
self.wgt_video = QVideoWidget(self.centralwidget)
self.wgt_video.setGeometry(QtCore.QRect(190, 40, 1280, 720))
self.player = QMediaPlayer()
self.player.setVideoOutput(self.wgt_video)
self.wgt_video.hide()
self.wgt_video.setObjectName("widget")
self.pushButton_play = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_play.setVisible(False)
self.pushButton_play.setGeometry(QtCore.QRect(1513, 40, 80, 41))
self.pushButton_play.setObjectName("pushButton")
self.video_is_play = False
self.pushButton_play.clicked.connect(self.video_play_change)
self.pushButton = QtWidgets.QPushButton(self.centralwidget)
self.pushButton.setGeometry(QtCore.QRect(100, 790, 161, 41))
self.pushButton.setObjectName("pushButton")
self.pushButton.clicked.connect(self.open_image)
self.pushButton1 = QtWidgets.QPushButton(self.centralwidget)
self.pushButton1.setGeometry(QtCore.QRect(883, 790, 161, 41))
self.pushButton1.setObjectName("pushButton")
self.pushButton1.clicked.connect(self.predict)
self.pushButton_camera = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_camera.setGeometry(QtCore.QRect(622, 790, 161, 41))
self.pushButton_camera.setObjectName("pushButton")
self.pushButton_camera.clicked.connect(self.camera)
self.check_continue = QtWidgets.QCheckBox(self.centralwidget)
self.check_continue.setGeometry(QtCore.QRect(622, 825, 100, 41))
self.check_continue.setObjectName("checkButton")
self.check_continue.stateChanged.connect(self.continue_camera)
self.label1 = QtWidgets.QLabel(self.centralwidget)
self.label1.setGeometry(QtCore.QRect(720, 825, 30, 41))
self.label1.setObjectName("label")
self.line_second = QtWidgets.QLineEdit(self.centralwidget)
self.line_second.setGeometry(QtCore.QRect(752, 834, 20, 20))
self.line_second.setObjectName("lineEdit")
self.line_second.setEnabled(False)
self.label2 = QtWidgets.QLabel(self.centralwidget)
self.label2.setGeometry(QtCore.QRect(774, 825, 30, 41))
self.label2.setObjectName("label")
self.pushButton_video = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_video.setGeometry(QtCore.QRect(361, 790, 161, 41))
self.pushButton_video.setObjectName("pushButton")
self.pushButton_video.clicked.connect(self.open_video)
self.pushButton_delete = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_delete.setGeometry(QtCore.QRect(1144, 790, 161, 41))
self.pushButton_delete.setObjectName("pushButton")
self.pushButton_delete.clicked.connect(self.delete)
self.pushButton_history = QtWidgets.QPushButton(self.centralwidget)
self.pushButton_history.setGeometry(QtCore.QRect(1405, 790, 161, 41))
self.pushButton_history.setObjectName("pushButton")
self.pushButton_history.clicked.connect(self.history)
ShadowRCNN.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(ShadowRCNN)
self.menubar.setGeometry(QtCore.QRect(0, 0, 1600, 26))
self.menubar.setAutoFillBackground(False)
self.menubar.setObjectName("menubar")
ShadowRCNN.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(ShadowRCNN)
self.statusbar.setObjectName("statusbar")
ShadowRCNN.setStatusBar(self.statusbar)
self.timer = QTimer()
self.retranslateUi(ShadowRCNN)
if self.is_guest:
self.pushButton_delete.setEnabled(False)
self.pushButton_history.setEnabled(False)
QtCore.QMetaObject.connectSlotsByName(ShadowRCNN)
def retranslateUi(self, ShadowRCNN):
_translate = QtCore.QCoreApplication.translate
ShadowRCNN.setWindowTitle(_translate("ShadowRCNN", "ShadowRCNN"))
self.label.setText(_translate("ShadowRCNN", "请选择图片"))
self.pushButton.setText(_translate("ShadowRCNN", "选择图片"))
self.pushButton1.setText(_translate("ShadowRCNN", "开始预测"))
self.pushButton_play.setText(_translate("ShadowRCNN", "暂停"))
self.pushButton_camera.setText(_translate("ShadowRCNN", "拍摄照片"))
self.pushButton_video.setText(_translate("ShadowRCNN", "选择视频"))
self.pushButton_delete.setText(_translate("ShadowRCNN", "删除缓存"))
self.pushButton_history.setText(_translate("ShadowRCNN", "历史信息"))
self.check_continue.setText(_translate("ShadowRCNN", "连拍模式"))
self.label1.setText(_translate("ShadowRCNN", "每秒"))
self.line_second.setText(_translate("ShadowRCNN", "1"))
self.label2.setText(_translate("ShadowRCNN", "张"))
self.label_name.setText(
_translate("ShadowRCNN", "欢迎使用，" + self.user_name))
def open_image(self):
self.image_choose_dialog = media_dialog(media_type='图片')
self.image_choose_dialog.show()
self.image_choose_dialog._signal.connect(self.get_image)
def get_image(self, imgName):
self.label.clear()
self.player.setMedia(QMediaContent())
self.wgt_video.hide()
self.label.show()
self.pushButton_play.setVisible(False)
jpg = QtGui.QPixmap(imgName).scaled(self.label.width(),
self.label.height())
if imgName != '':
self.label.setPixmap(jpg)
self.statusbar.showMessage('当前图片：' + imgName)
PARAMS['imgPath'] = imgName
self.image_choose_dialog.close()
def ARP_predict(self, mode='image'):
shadow_write_path, shadow_write_name = os.path.split(PARAMS['imgPath'])
shadow_write_name = shadow_write_name.split('.')[0] + '_shadow_' \
+ datetime.datetime.now().strftime('%Y%m%d%H%M%S') + '.' \
+ shadow_write_name.split('.')[1]
self.shadow_write_path = os.path.join(shadow_write_path,
shadow_write_name)
print(self.shadow_write_path)
if mode == 'image':
manager = multiprocessing.Manager()
return_dict = manager.dict()
p = multiprocessing.Process(target=ARP_predict,
args=(return_dict, PARAMS['imgPath'],
ARP_MODEL_NAME, ARP_PATH,
SHADOW_PERCENT))
p.start()
p.join()
PARAMS['ARP_result'] = return_dict.values()[0]
cv2.imwrite(self.shadow_write_path, PARAMS['ARP_result'])
if 'shadow_write_path' not in PARAMS.keys():
PARAMS['shadow_write_path'] = []
PARAMS['shadow_write_path'].append(self.shadow_write_path)
PARAMS['all_file_path'].append(self.shadow_write_path)
elif mode == 'video':
manager = multiprocessing.Manager()
return_dict = manager.dict()
p = multiprocessing.Process(
target=ARP_predict,
args=(return_dict, PARAMS['imgPath'], ARP_MODEL_NAME, ARP_PATH,
SHADOW_PERCENT, 'video', self.shadow_write_path))
p.start()
p.join()
PARAMS['all_file_path'].append(self.shadow_write_path)
def rcnn_predict(self, mode='image'):
rcnn_write_path, rcnn_write_name = os.path.split(PARAMS['imgPath'])
rcnn_write_name = rcnn_write_name.split('.')[0] + '_rcnn_' \
+ datetime.datetime.now().strftime('%Y%m%d%H%M%S') \
+ '.' + rcnn_write_name.split('.')[1]
self.rcnn_write_path = os.path.join(rcnn_write_path, rcnn_write_name)
print(self.rcnn_write_path)
if mode == 'image':
manager = multiprocessing.Manager()
return_dict = manager.dict()
p = multiprocessing.Process(target=rcnn_predict,
args=(return_dict,
PARAMS['ARP_result'], False,
RCNN_PATH))
p.start()
p.join()
PARAMS['RCNN_result'] = return_dict.values()[0]
if PARAMS['RCNN_result'] is not None:
cv2.imwrite(self.rcnn_write_path, PARAMS['RCNN_result'])
if 'rcnn_write_path' not in PARAMS.keys():
PARAMS['rcnn_write_path'] = []
PARAMS['rcnn_write_path'].append(self.rcnn_write_path)
PARAMS['all_file_path'].append(self.rcnn_write_path)
jpg = QtGui.QPixmap(self.rcnn_write_path).scaled(
self.label.width(), self.label.height())
self.label.setPixmap(jpg)
elif mode == 'video':
manager = multiprocessing.Manager()
return_dict = manager.dict()
p = multiprocessing.Process(
target=rcnn_predict,
args=(return_dict, self.shadow_write_path, False, RCNN_PATH,
'video', self.rcnn_write_path))
p.start()
p.join()
PARAMS['all_file_path'].append(self.rcnn_write_path)
self.player.setMedia(
QMediaContent(QUrl.fromLocalFile(self.rcnn_write_path)))
self.player.play()
self.video_is_play = True
self.pushButton_play.setText('暂停')
if not self.is_guest:
sql = 'insert into tb_record(path,shadow,type,user_id,param_id,time)values("%s","%s","%s",%s,%s,"%s")' \
% (str(self.rcnn_write_path).replace('\\', '/'), str(self.shadow_write_path).replace('\\', '/'),
mode, self.user_id, self.param_id,
str(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')))
db_insert(sql)
def predict(self):
if 'imgPath' in PARAMS.keys():
self.msgDialog = msg_dialog()
self.msgDialog.show()
self.timer = QTimer()
self.timer.timeout.connect(self.start_connect)
self.timer.start(500)
self.statusbar.showMessage('预测完成')
else:
msg = QMessageBox.information(self, '提示', '请先选择图片或视频',
QMessageBox.Yes, QMessageBox.Yes)
def continue_camera(self, state):
# state 0 没选中 1 选中
if state == 0:
self.pushButton_camera.setText('拍摄照片')
self.line_second.setEnabled(False)
elif state == 2:
self.pushButton_camera.setText('开始连拍')
self.line_second.setEnabled(True)
def camera(self):
self.label.clear()
self.player.setMedia(QMediaContent())
self.wgt_video.hide()
self.label.show()
self.pushButton_play.setVisible(False)
if self.check_continue.checkState() != QtCore.Qt.Checked:
self.pushButton_camera.setText('按Q拍照')
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read()
# show a frame
cv2.imshow("Capture", frame)
if cv2.waitKey(1) == ord('q'):
cap_name = IMAGE_PATH + '/capimg_' + str(
datetime.datetime.now().strftime(
'%Y%m%d%H%M%S%f')) + '.jpg'
cv2.imwrite(cap_name, frame)
jpg = QtGui.QPixmap(cap_name).scaled(
self.label.width(), self.label.height())
self.label.setPixmap(jpg)
cap.release() # 释放摄像头
cv2.destroyAllWindows() # 删除建立的全部窗口
PARAMS['imgPath'] = cap_name
PARAMS['all_file_path'].append(cap_name)
self.pushButton_camera.setText('拍摄照片')
break
if cv2.getWindowProperty("Capture", cv2.WND_PROP_AUTOSIZE) < 1:
cv2.destroyAllWindows()
self.pushButton_camera.setText('拍摄照片')
break
else:
self.now_continue_num = 0
self.pushButton_camera.setEnabled(False)
self.pushButton_camera.setText('正在连拍')
per_second_photo_num = self.line_second.text()
self.msgDialog = msg_dialog(msg='准备开始连拍')
self.cap = cv2.VideoCapture(0)
self.msgDialog.show()
self.msgDialog.move(1200, 500)
self.timer = QTimer()
self.continue_list = []
self.timer.timeout.connect(self.start_continue_photo)
self.timer.start(int(1000 / int(per_second_photo_num)))
def start_continue_photo(self):
self.now_continue_num += 1
self.msgDialog.setWindowTitle('正在连拍')
self.msgDialog.msg_dialog.label.setText('正在拍摄第 {}/9 张...'.format(
self.now_continue_num))
# 拍照
ret, frame = self.cap.read()
# show a frame
cv2.imshow("Capture", frame)
image_name = IMAGE_PATH + '/capimg_' + str(
datetime.datetime.now().strftime('%Y%m%d%H%M%S%f')) + '.jpg'
cv2.imwrite(image_name, frame)
PARAMS['all_file_path'].append(image_name)
self.continue_list.append(image_name)
# 结束拍照
if self.now_continue_num == 9:
self.timer.stop()
self.msgDialog.msg_dialog.label.setText('正在处理结果')
self.pushButton_camera.setText('开始连拍')
self.pushButton_camera.setEnabled(True)
self.msgDialog.close()
cv2.destroyAllWindows()
self.cap.release()
# 横向拼接结果
continue_list_middle = [
np.hstack([
cv2.imread(self.continue_list[0], 1),
cv2.imread(self.continue_list[1], 1),
cv2.imread(self.continue_list[2], 1)
]),
np.hstack([
cv2.imread(self.continue_list[3], 1),
cv2.imread(self.continue_list[4], 1),
cv2.imread(self.continue_list[5], 1)
]),
np.hstack([
cv2.imread(self.continue_list[6], 1),
cv2.imread(self.continue_list[7], 1),
cv2.imread(self.continue_list[8], 1)
])
]
# 纵向拼接
continue_photo = np.vstack([
continue_list_middle[0], continue_list_middle[1],
continue_list_middle[2]
])
# 展示结果
continue_photo_name = os.path.join(
IMAGE_PATH, self.continue_list[0][:-10] + '_9in1.jpg')
PARAMS['imgPath'] = continue_photo_name
PARAMS['all_file_path'].append(continue_photo_name)
cv2.imwrite(continue_photo_name, continue_photo)
jpg = QtGui.QPixmap(continue_photo_name).scaled(
self.label.width(), self.label.height())
self.label.setPixmap(jpg)
def open_video(self):
self.video_choose_dialog = media_dialog(media_type='视频')
self.video_choose_dialog.show()
self.video_choose_dialog._signal.connect(self.get_video)
def get_video(self, videoName):
if videoName != '':
self.label.clear()
self.player.setMedia(QMediaContent())
self.wgt_video.show()
self.label.hide()
self.player.setMedia(QMediaContent(QUrl.fromLocalFile(videoName)))
self.player.play()
self.video_is_play = True
self.pushButton_play.setVisible(True)
self.statusbar.showMessage('当前视频：' + videoName)
PARAMS['imgPath'] = videoName
self.video_choose_dialog.close()
def video_play_change(self):
self.video_is_play = bool(1 - self.video_is_play)
if self.video_is_play:
self.player.play()
self.pushButton_play.setText('暂停')
else:
self.player.pause()
self.pushButton_play.setText('播放')
def delete(self):
file_num = 0
for file_name in PARAMS['all_file_path']:
if os.path.exists(file_name):
os.remove(file_name)
if '_rcnn' in file_name:
sql = 'delete from tb_record where path="%s"' % file_name.replace(
'\\', '/')
db_delete(sql)
file_num += 1
self.statusbar.showMessage('缓存清除成功，共' + str(file_num) + '个文件')
self.label.clear()
self.player.setMedia(QMediaContent())
def history(self):
self.his_dialog = history_dialog(self.user_id, self.user_name)
self.his_dialog.show()
def start_connect(self):
if str(PARAMS['imgPath']).endswith(('png', 'jpg')):
self.ARP_predict()
self.rcnn_predict()
else:
self.ARP_predict(mode='video')
self.rcnn_predict(mode='video')
self.timer.stop()
self.msgDialog.close()
class Final(QWidget):
def __init__(self):
super().__init__()
self.setGeometry(0, 0, w, h)
self.backgroundImage = QLabel(self)
self.textBubble = QLabel(self)
self.previousButton = QPushButton(self)
self.nextButton = QPushButton(self)
self.textField = QLabel(self)
# self.video = VideoPlayer(self)
self.inputPassword = QLineEdit(self)
self.checkButton = QPushButton('QED', self)
self.initWindow()
self.show()
def initWindow(self):
pixmap = QPixmap(
resource_path("./images/examen3/merceClasse2.JPG")).scaled(w, h)
self.backgroundImage.setPixmap(pixmap)
self.previousButton.move(0.12 * w, 0.83 * h)
self.previousButton.setIcon(
QIcon(resource_path('./images/icons/previous.png')))
self.previousButton.setStyleSheet(
"QPushButton{background: transparent;}")
self.previousButton.hide()
bubblePM = QPixmap(resource_path("./images/icons/textBubble.png"))
self.textBubble.setPixmap(bubblePM)
self.textBubble.move(0.1 * w, 0.75 * h)
self.textField.setText(
'''<p> - I la resposta és... 432! Doncs crec que ja ho tindríem, primer exercici... segon exercici... i tercer! Tots acabats i en fulls separats, crec que va sent hora d'entregar aquest examen d'aquesta assignatura de merda, per fi me'n puc desfer, per fi podré no gastar l'hora i mitja de dilluns i divendres que els meus solidaris companys feien servir per restregar-me lo bé que s'ho passaven fent birres al bar. I tot això? Per a què? Per a que acabin traient la mateixa nota que jo, o millor? N'estic fart. <b> ( Silenci ) </b> Hola Morsè, et vinc a entregar el final de la millor assignatura que he fet en la meva vida, gràcies per tot.</p>'''
)
self.textField.setAlignment(Qt.AlignJustify)
self.textField.setWordWrap(True)
self.textField.resize(600, 200)
self.textField.move(0.167 * w, 0.76 * h)
self.textField.show()
self.inputPassword.setGeometry(0.2 * w, 0.83 * h, 0.2 * w, 0.04 * h)
self.inputPassword.setMaxLength(20)
self.inputPassword.setFrame(False)
self.inputPassword.hide()
self.checkButton.move(0.45 * w, 0.83 * h)
self.checkButton.clicked.connect(self.checkAnswerSecondExercise)
self.checkButton.hide()
self.nextButton.move(0.85 * w, 0.83 * h)
self.nextButton.setIcon(QIcon(
resource_path('./images/icons/next.png')))
self.nextButton.setStyleSheet("QPushButton{background: transparent;}")
try:
self.nextButton.clicked.disconnect()
self.textBubble.show()
self.textField.show()
self.nextButton.show()
except:
pass
self.nextButton.clicked.connect(self.finalFirst)
# self.video.resize(w, h)
# self.video.hide()
self.hide()
self.show()
def finalFirst(self):
self.textField.setText(
'''<p> <b> Morsè Oller: </b> . ... -.-. --- .-.. - .- -. --- .. -. --- .... .- ... .--. --- ... .- - .-. . ... .- .-.. ·----· .- .--. .- .-. - .- - -.. ·----· .- ... ... .. --. -. .- - ..- .-. .- <br> - Que no he posat res a l'apartat d'assignatura?! (M'ha enxampat) És que... com t'explico això Morsè... resulta que aquesta part no me l'he pogut estudiar, tenia pensat fer-ho avui al matí però... al final m'he liat (toma aresta) i no he pogut... No tindries pas una pista per ajudar-me? De quina assignatura estem parlant?</p>'''
)
self.textField.setAlignment(Qt.AlignJustify)
self.textField.setWordWrap(True)
self.textField.resize(600, 200)
self.textField.move(0.167 * w, 0.78 * h)
try:
self.previousButton.clicked.disconnect()
except:
pass
self.previousButton.clicked.connect(self.initWindow)
self.nextButton.clicked.disconnect()
self.nextButton.clicked.connect(self.videoFinal)
def videoFinal(self):
self.nextButton.hide()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget(self)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(path)))
self.videoWidget.show()
self.videoWidget.resize(w, h)
self.textField.hide()
self.textBubble.hide()
self.backgroundImage.hide()
self.nextNewButton = QPushButton(self)
self.nextNewButton.setStyleSheet(
"QPushButton{background-color: white;}")
# self.nextNewButton.setStyleSheet("QPushButton{background: transparent;}")
self.nextNewButton.move(0.85 * w, 0.83 * h)
self.nextNewButton.setIcon(
QIcon(resource_path('./images/icons/next.png')))
self.nextNewButton.show()
self.mediaPlayer.play()
# self.video.show()
try:
self.nextNewButton.clicked.disconnect()
except:
pass
self.nextNewButton.clicked.connect(self.finalAnswer)
def finalAnswer(self):
self.nextNewButton.hide()
self.videoWidget.hide()
self.textField.setText(
'''<p> - Finalment, de quina assignatura ha sigut l'examen que has fet avui? </p>'''
)
self.textField.setAlignment(Qt.AlignJustify)
self.textField.setWordWrap(True)
self.textField.resize(600, 200)
self.textField.move(0.167 * w, 0.78 * h)
self.inputPassword.show()
self.checkButton.show()
self.textField.show()
self.textBubble.show()
def checkAnswerSecondExercise(self):
self.finalFinal = FinalFinal()
self.close()
class Window(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
self.k = 0
self.init_ui()
def init_ui(self):
self.setWindowTitle('SyncMedia')
self.play = QtWidgets.QPushButton(self)
self.stop = QtWidgets.QPushButton(self)
self.play.setText('Play')
self.stop.setText('Stop')
self.label = QtWidgets.QLabel("Volume", self)
self.Slider = QtWidgets.QSlider(self)
self.Slider.setRange(0, 100)
self.Slider.sliderMoved.connect(self.setPosition)
self.Slider.setOrientation(Qt.Horizontal)
self.Slider.setFocusPolicy(Qt.NoFocus)
self.VSlider = QtWidgets.QSlider(self)
self.VSlider.sliderMoved.connect(self.setVPosition)
self.VSlider.setRange(0, 10)
self.VSlider.setOrientation(Qt.Horizontal)
self.VSlider.setFocusPolicy(Qt.NoFocus)
openAction = QtWidgets.QAction(QtGui.QIcon('open.png'), '&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open mp4 movie')
openAction.triggered.connect(self.openFile)
menu = self.menuBar()
file = menu.addMenu(' &File ')
file.addAction(openAction)
self.play.clicked.connect(self.play_click)
self.stop.clicked.connect(self.stop_click)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoWidget = QVideoWidget()
wid = QtWidgets.QWidget(self)
self.setCentralWidget(wid)
wid.resize(wid.sizeHint())
wid.setAutoFillBackground(True)
p = wid.palette()
p.setColor(wid.backgroundRole(), Qt.black)
wid.setPalette(p)
self.Slider.setAutoFillBackground(True)
p = self.Slider.palette()
p.setColor(self.Slider.backgroundRole(), Qt.black)
self.Slider.setPalette(p)
controlLayout = QtWidgets.QHBoxLayout()
controlLayout.addWidget(self.play)
controlLayout.addWidget(self.stop)
controlLayout.addStretch(1)
controlLayout.addWidget(self.label)
controlLayout.addWidget(self.VSlider)
extralayout = QtWidgets.QHBoxLayout()
extralayout.addWidget(self.videoWidget)
layout = QtWidgets.QVBoxLayout()
layout.addLayout(extralayout)
self.videoWidget.update()
layout.addWidget(self.Slider)
layout.addLayout(controlLayout)
wid.setLayout(layout)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.videoWidget.show()
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.show()
def play_click(self):
if (self.k == 0):
self.mediaPlayer.play()
self.play.setText('Pause')
self.videoWidget.update()
self.k = 1
elif (self.k == 1):
self.mediaPlayer.pause()
self.play.setText('Play')
self.k = 0
def stop_click(self):
self.mediaPlayer.stop()
self.play.setText('Play')
self.k = 0
def openFile(self):
fileName, _ = QtWidgets.QFileDialog.getOpenFileName(
self, "Open Movie", QDir.homePath())
self.setWindowTitle(f'SyncMedia - {fileName}')
if fileName != '':
print(fileName)
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(fileName)))
def positionChanged(self, position):
self.Slider.setValue(position)
def durationChanged(self, duration):
self.Slider.setRange(0, duration)
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def setVPosition(self, position):
self.mediaPlayer.setVolume(position * 10)
class Window(QWidget):
COLUMNS_DICT = {
# "Column label": {'index': column_ID, 'width': column_width}
"ID": {
"index": 0,
"width": 25
},
"File name": {
"index": 1,
"width": 165
},
"Format": {
"index": 2,
"width": 50
},
"Dup": {
"index": 3,
"width": 5
},
}
def __init__(self, statusBar):
super().__init__()
# store active image ID
self.active_image_id = str()
# Saves multiple duplicate windows references:
self.duplicateRefs = {}
# Gets status bar from QMainWindow:
self.statusBar = statusBar
# Initializes all window elements:
self.folderField = QLineEdit()
self.folderButton = QPushButton()
self.folderTreeCheckbox = QCheckBox("Include sub-folders")
self.processButton = QPushButton("Process media files")
self.duplicateButton = QPushButton("Find duplicates")
self.reindexButton = QPushButton("Reindex database files")
self.tableTabs = QTabWidget()
# init main images list table
self.imageListTable = QTableWidget()
# set main images list table fields unchanged
self.imageListTable.setEditTriggers(QTableWidget.NoEditTriggers)
# init main videos list table
self.videoListTable = QTableWidget()
# set main videos list table fields unchanged
self.videoListTable.setEditTriggers(QTableWidget.NoEditTriggers)
# set up image fields and elements
self.imageField = QLabel()
self.imageNameField = QLabel()
self.imageParamsField = QLabel()
self.imageCopyButton = QPushButton("Copy image")
self.imageCopyButton.setIcon(QIcon("gui/static/icon_copy.png"))
self.imageCopyButton.clicked.connect(self.copy_image_path)
self.imageViewButton = QPushButton("View image")
self.imageViewButton.setIcon(QIcon("gui/static/icon_open_image.svg"))
self.imageViewButton.clicked.connect(self.open_image_file)
self.imageOpenDirButton = QPushButton("Open dir")
self.imageOpenDirButton.setIcon(
QIcon("gui/static/icon_open_folder.svg"))
self.imageOpenDirButton.clicked.connect(self.open_image_path)
self.imageDeleteButton = QPushButton("Delete")
self.imageDeleteButton.setIcon(
QIcon("gui/static/icon_delete_file.png"))
self.imageDeleteButton.clicked.connect(self.delete_image)
self.videoField = QVideoWidget()
self.videoPlayer = QMediaPlayer()
# Adjusts settings for the window elements:
self.folderField.setDisabled(True)
self.folderButton.setIcon(QIcon("gui/static/icon_process_folder.png"))
self.folderButton.clicked.connect(self.set_folder)
self.processButton.clicked.connect(self.process_files)
self.processButton.setFixedWidth(160)
self.processButton.setDisabled(True)
self.duplicateButton.clicked.connect(self.find_duplicates)
self.duplicateButton.setFixedWidth(160)
self.reindexButton.clicked.connect(self.reindex_db_data)
self.reindexButton.setFixedWidth(160)
# prepare tables for images and videos
self.imagesTab = self.tableTabs.insertTab(0, self.imageListTable,
"Images")
self.videosTab = self.tableTabs.insertTab(1, self.videoListTable,
"Videos")
# images list table setup
self.imageListTable.setColumnCount(len(self.COLUMNS_DICT.keys()))
self.imageListTable.setHorizontalHeaderLabels(self.COLUMNS_DICT.keys())
self.imageListTable.verticalHeader().setVisible(False)
self.imageListTable.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.imageListTable.setSortingEnabled(True)
self.imageListTable.cellClicked.connect(self.show_image)
# videos list table setup
self.videoListTable.setColumnCount(len(self.COLUMNS_DICT.keys()))
self.videoListTable.setHorizontalHeaderLabels(self.COLUMNS_DICT.keys())
self.videoListTable.verticalHeader().setVisible(False)
self.videoListTable.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.videoListTable.setSortingEnabled(True)
self.videoListTable.cellClicked.connect(self.show_video)
# set images and videos duplicates columns width
self.set_columns_width()
# Places the window elements on the window:
# Top-left cell of main grid box:
subGridBox = QWidget()
subGrid = QGridLayout()
subGrid.addWidget(self.folderField, 0, 0)
subGrid.addWidget(self.folderButton, 0, 1)
subGrid.addWidget(self.folderTreeCheckbox, 1, 0)
subGrid.addWidget(self.processButton, 2, 0, 1, 2, Qt.AlignCenter)
subGrid.addWidget(self.duplicateButton, 3, 0, 1, 2, Qt.AlignCenter)
subGrid.addWidget(self.reindexButton, 4, 0, 1, 2, Qt.AlignCenter)
subGridBox.setLayout(subGrid)
# image data grid box
imageGridBox = QWidget()
imageGrid = QGridLayout()
imageGrid.addWidget(self.imageField, 0, 0, 1, 4, Qt.AlignCenter)
# add image buttons
imageGrid.addWidget(self.imageCopyButton, 1, 0, 1, 1)
imageGrid.addWidget(self.imageViewButton, 1, 1, 1, 1)
imageGrid.addWidget(self.imageOpenDirButton, 1, 2, 1, 1)
imageGrid.addWidget(self.imageDeleteButton, 1, 3, 1, 1)
imageGrid.addWidget(self.imageNameField, 2, 0, 1, 1)
imageGrid.addWidget(self.imageParamsField, 2, 3, 1, 1)
imageGridBox.setLayout(imageGrid)
# Main grid box:
self.mainGrid = QGridLayout()
self.mainGrid.addWidget(subGridBox, 0, 0)
self.mainGrid.addWidget(self.tableTabs, 1, 0)
self.mainGrid.addWidget(imageGridBox, 1, 1)
self.mainGrid.addWidget(self.videoField, 0, 1, 2, 1)
self.mainGrid.setColumnMinimumWidth(0, 400)
self.mainGrid.setRowMinimumHeight(1, 600)
self.mainGrid.setColumnStretch(1, 1)
self.setLayout(self.mainGrid)
# Creates a QThread instance:
self.thread = ProcessingThread(self.folderField, self.imageListTable,
self.videoListTable,
self.folderTreeCheckbox)
self.thread.finishedTrigger.connect(self.finish_thread)
# filling table while first run
self.reindex_db_data()
# hide image interface
self.hide_active_image()
def set_columns_width(self):
# looping all columns and set with
for value in self.COLUMNS_DICT.values():
self.imageListTable.setColumnWidth(value["index"], value["width"])
self.videoListTable.setColumnWidth(value["index"], value["width"])
def reindex_db_data(self):
self.duplicateButton.setDisabled(True)
self.processButton.setDisabled(True)
self.reindexButton.setDisabled(True)
# Reindex already exist folders and files; Image and Video files
reindex_image_files()
reindex_video_files()
# run table filling after reindexing
self.table_data_init()
self.duplicateButton.setEnabled(True)
self.processButton.setEnabled(True)
self.reindexButton.setEnabled(True)
def center_widget_item(self, text: str) -> QTableWidgetItem:
# create the item
center_align_item = QTableWidgetItem(text)
# change the alignment
center_align_item.setTextAlignment(Qt.AlignCenter)
return center_align_item
def table_data_init(self):
# get available images from DB
with db_session():
images = Image.all()
for idx, image in enumerate(images):
numRows = self.imageListTable.rowCount()
self.imageListTable.insertRow(numRows)
str_image_idx = str(idx)
IMAGE_PATH_DICT[str_image_idx] = {
"id": image.id,
"name": image.image_name,
"additional_attrs": {
"height": image.image_height,
"width": image.image_width
},
"folder": image.image_path,
"type": (image.image_name.split(".")[-1]).lower(),
"full_path": image.full_path(),
}
self.imageListTable.setItem(idx, self.COLUMNS_DICT["ID"]["index"],
self.center_widget_item(str_image_idx))
self.imageListTable.setItem(
idx,
self.COLUMNS_DICT["File name"]["index"],
self.center_widget_item(image.image_name),
)
self.imageListTable.setItem(
idx,
self.COLUMNS_DICT["Format"]["index"],
self.center_widget_item(
IMAGE_PATH_DICT[str_image_idx]["type"]),
)
duplicateIcon = QTableWidgetItem()
duplicateIcon.setIcon(QIcon("gui/static/icon_view_duplicates.png"))
self.imageListTable.setItem(idx, self.COLUMNS_DICT["Dup"]["index"],
duplicateIcon)
def hide_active_image(self):
self.imageField.hide()
self.imageCopyButton.hide()
self.imageViewButton.hide()
self.imageOpenDirButton.hide()
self.imageDeleteButton.hide()
self.imageNameField.hide()
self.imageParamsField.hide()
def show_active_image(self):
self.imageField.show()
self.imageCopyButton.show()
self.imageViewButton.show()
self.imageOpenDirButton.show()
self.imageDeleteButton.show()
self.imageNameField.show()
self.imageParamsField.show()
def open_image_file(self):
open_path(path=IMAGE_PATH_DICT[self.active_image_id]["full_path"])
def open_image_path(self):
open_path(path=IMAGE_PATH_DICT[self.active_image_id]["folder"])
def delete_image(self):
# count image table position
image_table_position = list(IMAGE_PATH_DICT.keys()).index(
self.active_image_id)
message = QMessageBox().question(
self,
"Confirm deletion",
"Delete duplicate media file?",
QMessageBox.Yes | QMessageBox.No,
)
if message == QMessageBox.Yes:
self.imageListTable.removeRow(image_table_position)
image_id = IMAGE_PATH_DICT[self.active_image_id]["id"]
# run custom delete
with db_session():
Image[image_id].custom_delete()
# delete image key from dict
del IMAGE_PATH_DICT[self.active_image_id]
self.hide_active_image()
QMessageBox().information(self, "File deletion",
"File success deleted", QMessageBox.Ok,
QMessageBox.Ok)
elif message == QMessageBox.No:
pass
def copy_image_path(self):
try:
result = copy_image(
IMAGE_PATH_DICT[self.active_image_id]["full_path"])
if result:
QMessageBox.information(
self,
"Copy path",
"Success!\nFile copied to clipboard!",
QMessageBox.Ok,
QMessageBox.Ok,
)
else:
QMessageBox.warning(
self,
"Copy path",
"Error!\nSorry, i can`t copy image to clipboard.",
QMessageBox.Ok,
QMessageBox.Ok,
)
except Exception:
print(traceback.format_exc())
QMessageBox.warning(
self,
"Copy path",
f"Error!\n{traceback.format_exc()}",
QMessageBox.Ok,
QMessageBox.Ok,
)
# Get a folder full of multimedia files to work with
def set_folder(self):
self.folderPath = QFileDialog.getExistingDirectory(self)
if self.folderPath == "":
self.folderPath = self.folderField.text()
self.folderField.setText(self.folderPath)
self.processButton.setEnabled(True)
self.statusBar.clearMessage()
# Start the thread and fill the table with those files
def process_files(self):
# set other buttons disabled
self.duplicateButton.setDisabled(True)
self.reindexButton.setDisabled(True)
# Clears both tables upon restarting function:
self.imageListTable.clearContents()
self.imageListTable.setRowCount(0)
self.videoListTable.clearContents()
self.videoListTable.setRowCount(0)
self.statusBar.setStyleSheet("color: black")
self.statusBar.showMessage("Processing...")
if self.folderField.text() == "":
self.statusBar.setStyleSheet("color: red")
self.statusBar.showMessage("Please choose a directory")
self.duplicateButton.setEnabled(True)
self.reindexButton.setEnabled(True)
return None
if not self.thread.isRunning():
self.duplicateRefs.clear()
self.thread.start()
self.processButton.setText("Stop")
elif self.thread.isRunning():
self.thread.terminate()
self.processButton.setText("Process media files")
self.duplicateButton.setEnabled(True)
self.reindexButton.setEnabled(True)
# Thread done and ded
def finish_thread(self):
self.statusBar.setStyleSheet("color: black")
self.statusBar.showMessage("Finished!")
self.processButton.setText("Process media files")
# set all buttons able
self.duplicateButton.setEnabled(True)
self.reindexButton.setEnabled(True)
# Start the second thread and remove all unique files from the table
def find_duplicates(self):
if IMAGE_PATH_DICT == {}:
self.statusBar.setStyleSheet("color: red")
self.statusBar.showMessage("Please process your media files first")
return None
self.duplicateButton.setDisabled(True)
self.processButton.setDisabled(True)
self.reindexButton.setDisabled(True)
self.statusBar.setStyleSheet("color: black")
self.statusBar.showMessage("Finding duplicates...")
with db_session():
# get all images descriptors
image_files_query = Image.get_descriptors()
pairs_amount = int(
len(image_files_query) * (len(image_files_query) - 1) / 2)
QMessageBox.information(
self,
"Find duplicates",
f"""
Similar images search start. Please wait!\n
You have ~{pairs_amount} images pairs;
Work will get ~{round(pairs_amount*0.00006, 2)} sec.
""",
QMessageBox.Ok,
QMessageBox.Ok,
)
# run function to find duplicates
result = feature_description(images_list=image_files_query)
with db_session():
# save duplicates to DB
save_images_duplicates(result)
QMessageBox.information(self, "Find duplicates", "Success!",
QMessageBox.Ok, QMessageBox.Ok)
# set all buttons able
self.duplicateButton.setEnabled(True)
self.reindexButton.setEnabled(True)
self.processButton.setEnabled(True)
# TODO: new thread removing all unique media. Only duplicates remain
# Show an image upon clicking its name in the table
def show_image(self, row, column):
imageId = self.imageListTable.item(row, 0).text()
# set new active image id
self.active_image_id = imageId
# Removes a video from screen if shown:
self.videoPlayer.stop()
self.videoField.hide()
# show active image
self.show_active_image()
# show image and additional data
self.imageNameField.setText(f"{IMAGE_PATH_DICT[imageId]['name']}")
self.imageParamsField.setText(
f"HxW: {IMAGE_PATH_DICT[imageId]['additional_attrs']['height']}px"
+ f" x {IMAGE_PATH_DICT[imageId]['additional_attrs']['width']}px")
# Shows animated images
if IMAGE_PATH_DICT[imageId]["name"].lower().endswith("gif"):
gif = QMovie(IMAGE_PATH_DICT[imageId]["full_path"])
gifSize = QSize(*self.smooth_gif_resize(
IMAGE_PATH_DICT[imageId]["full_path"], 600, 600))
gif.setScaledSize(gifSize)
self.imageField.setMovie(gif)
gif.start()
# Shows static images
else:
self.imageField.setPixmap(
QPixmap(IMAGE_PATH_DICT[imageId]["full_path"]).scaled(
600, 600, Qt.KeepAspectRatio, Qt.SmoothTransformation))
if column == self.COLUMNS_DICT["Dup"]["index"]:
self.duplicateWindow = DuplicateWindow(
image_data=IMAGE_PATH_DICT[imageId], raw_id=imageId)
if imageId not in self.duplicateRefs.keys():
self.duplicateRefs[imageId] = self.duplicateWindow
self.duplicateWindow.show()
self.duplicateWindow.closeTrigger.connect(self.delete_reference)
# Show a video upon clicking its name in the table
def show_video(self, row, column):
videoItem = self.videoListTable.item(row, column)
videoId = self.videoListTable.item(row, 0).text()
self.mainGrid.setColumnMinimumWidth(1, 800)
# Prevents from KeyError when clicking the second column:
if videoItem.text() == VIDEO_PATH_DICT[videoId][0]:
videoItemPath = VIDEO_PATH_DICT[videoId][2]
videoContent = QMediaContent(QUrl.fromLocalFile(videoItemPath))
self.videoPlayer.setMedia(videoContent)
self.videoPlayer.setVideoOutput(self.videoField)
# Removes an image from screen if shown and starts video:
self.imageField.clear()
self.imageField.hide()
self.videoField.show()
self.videoPlayer.play()
# Remove a previously added reference from a dict if a DuplicateWindow was closed
# so it can be opened again
def delete_reference(self, itemId):
self.duplicateRefs.pop(itemId)
# An amazing workaround for gif resizing procedure
# because PyQt's native one doesn't work for some reason:
def smooth_gif_resize(self, gif, frameWidth, frameHeight):
gif = Pil_Image.open(gif)
gifWidth0, gifHeight0 = gif.size
widthRatio = frameWidth / gifWidth0
heightRatio = frameHeight / gifHeight0
if widthRatio >= heightRatio:
gifWidth1 = gifWidth0 * heightRatio
gifHeight1 = frameHeight
return gifWidth1, gifHeight1
gifWidth1 = frameWidth
gifHeight1 = gifHeight0 * widthRatio
return gifWidth1, gifHeight1
class MindReaderApp(QtWidgets.QMainWindow, design.Ui_MainWindow):
def __init__(self):
# Это здесь нужно для доступа к переменным, методам
# и т.д. в файле design.py
super().__init__()
self.setupUi(self) # Это нужно для инициализации нашего дизайна
self.setWindowTitle("MindReader")
self.startButton.clicked.connect(self.start_timer)
self.timer = None
self.time = QtCore.QTime(0, 0, 0)
self.maxTimer = 0.0
# настраиваем графики
self.plot1 = self.graphic1.addPlot()
self.curve1 = self.plot1.plot()
self.plot2 = self.graphic2.addPlot()
self.curve2 = self.plot2.plot()
self.setGraphs()
# задаем массивы для хранения данных
self.data1 = []
self.data2 = []
self.timings = []
self.emotions = []
self.counter = 0
self.counter1 = 0
# для кнопки
self.clicked = False
# настройка видео
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.qw = QWidget()
self.qw.setGeometry(10, 360, 611, 280)
self.qw.setParent(self)
self.faceVideoWidget = QVideoWidget()
self.faceVideoWidget.setParent(self.qw)
self.faceVideoWidget.show()
self.facePlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.facePlayer.setVideoOutput(self.faceVideoWidget)
self.facePlayer.durationChanged.connect(self.getDuration)
self.chooseVideo.triggered.connect(self.openFile)
self.videoChosed = False
# для записи лица
self.videoTimer = None
self.frame = None
self.capture = None
self.fps = int(30)
self.videoSaver = None
if not os.path.exists('Recordings'):
os.makedirs('Recordings')
# настройка порта
self.ser = serial.Serial()
self.ser.baudrate = 57600
self.port = ""
self.choosePort.triggered.connect(self.inputCom)
# файл
if not os.path.exists('Sessions'):
os.makedirs('Sessions')
self.vidFileName = ""
self.faceFileName = ""
# для считки
self.fromFile = False
act = QAction("Выбрать файл", self)
act.triggered.connect(self.loadFile)
self.openPrevSession.addAction(act)
act1 = QAction("Очистить", self)
act1.triggered.connect(self.cancel)
self.openPrevSession.addAction(act1)
# файл настроек
self.sname = 'settings.txt'
self.emotions = []
if not os.path.isfile(self.sname):
self.f = open(self.sname, 'w')
self.f.close()
self.f = open(self.sname, 'r')
#для считки настроек из файла
self.settings.addAction(self.setEmotions)
self.setEmotionsData.triggered.connect(self.loadSettings)
# эмоции
self.settings = SettingsWindow()
self.setEmotions.triggered.connect(self.openSettings)
self.emotionsList = []
def cancel(self):
self.fromFile = False
def stop(self):
self.startButton.setText("Запустить")
self.timer.stop()
self.timer.deleteLater()
self.pause_video()
self.mediaPlayer.stop()
self.facePlayer.stop()
self.clicked = False
# show all in graphics
xdict = dict(enumerate(self.timings))
self.plot1.getAxis('bottom').setTicks([xdict.items()])
self.curve1.setData(self.data1)
self.plot2.getAxis('bottom').setTicks([xdict.items()])
self.curve2.setData(self.data2)
# close file
self.f.close()
# запускает таймер, который работает сколько влезет, пауза кнопкой
def start_timer(self):
if self.clicked:
self.stop()
else:
if self.fromFile:
try:
self.faceWidget.hide()
self.facePlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(self.faceFileName)))
self.qw.show()
self.facePlayer.play()
self.start = time.time()
except Exception as e:
QMessageBox.about(self, "Ошибка!",
"Видеофайл отсутствует или поврежден.")
if not self.fromFile:
if self.port == "":
QMessageBox.about(self, "Ошибка!", "Выберите COM порт!")
return
if not self.videoChosed:
QMessageBox.about(
self, "Ошибка!",
"Выберите видеофайл для воспроизведения!")
return
# открытие порта
self.ser.port = self.port
if not self.ser.isOpen():
try:
self.ser.open()
except serial.SerialException:
QMessageBox.about(self, "Ошибка!",
"Выберите работающий COM порт!")
return
self.qw.hide()
self.faceWidget.show()
self.set_camera(self.frame)
# reset data for graphs
self.data1 = []
self.data2 = []
self.timings = []
self.emotions = []
self.plot1.getAxis('bottom').setTicks([])
self.plot2.getAxis('bottom').setTicks([])
# new file
self.fname = str(
len([
name for name in os.listdir('Sessions')
if os.path.isfile(os.path.join('Sessions', name))
])) + '.emtn'
if not os.path.isfile('Sessions/' + self.fname):
self.f = open('Sessions/' + self.fname, 'w')
self.f.close()
self.f = open('Sessions/' + self.fname, 'r')
self.f = open('Sessions/' + self.fname, 'w')
self.f.write(self.vidFileName + "\n")
self.f.write(os.getcwd() +
'/Recordings/{}.avi'.format(self.faceFileName) +
"\n")
self.startButton.setText("Остановить")
self.counter = 0
self.counter1 = 0
self.emotionsList = self.settings.emotions
self.mediaPlayer.setMedia(
QMediaContent(QUrl.fromLocalFile(self.vidFileName)))
self.time = QtCore.QTime(0, 0, 0)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(4)
self.mediaPlayer.play()
self.clicked = True
def set_camera(self, frame):
try:
if not self.fromFile:
self.capture = cv2.VideoCapture(0)
self.width = self.capture.get(cv2.CAP_PROP_FRAME_WIDTH)
self.height = self.capture.get(cv2.CAP_PROP_FRAME_HEIGHT)
self.fps = self.capture.get(cv2.CAP_PROP_FPS)
if self.fps == 0 or self.fps == -1:
self.fps = int(25)
print(
"Warning: OpenCV failed to get your camera's frame rate, set to {}."
.format(self.fps))
# start
fourcc = cv2.VideoWriter_fourcc(*'XVID')
self.faceFileName = len([
name for name in os.listdir('Recordings')
if os.path.isfile(os.path.join('Recordings', name))
])
self.videoSaver = cv2.VideoWriter(
'Recordings/{}.avi'.format(self.faceFileName), fourcc,
cv2.CAP_PROP_FPS, (int(self.width), int(self.height)))
self.start_video()
except Exception as e:
self.capture = None
QMessageBox.about(self, "Ошибка!",
"Невозможно использовать вашу камеру.")
print(str(e))
def _draw_frame(self, frame):
# convert to pixel
cvtFrame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
img = QImage(cvtFrame, self.width, self.height, QImage.Format_RGB888)
pix = QPixmap.fromImage(img)
self.faceWidget.setPixmap(pix)
outFrame = cv2.cvtColor(cvtFrame, cv2.COLOR_BGR2RGB)
self.videoSaver.write(outFrame)
QtGui.QApplication.processEvents()
def _next_frame(self):
try:
if self.capture is not None:
_ret, frame = self.capture.read()
if frame is None:
QMessageBox.about(self, "Ошибка!",
"Ошибка считывания изображения.")
print(
"ERROR: Read next frame failed with returned value {}."
.format(_ret))
# Draw.
self._draw_frame(frame)
except Exception as e:
QMessageBox.about(self, "Ошибка!",
"Ошибка считывания изображения.")
print(str(e))
# Saving output video
if self.videoSaver:
self.videoSaver.release()
def start_video(self):
self.videoTimer = QtCore.QTimer()
self.videoTimer.timeout.connect(self._next_frame)
self.videoTimer.start(1000 // self.fps)
def pause_video(self):
try:
if self.capture != None:
self.capture.release()
self.capture = None
self.faceWidget.clear()
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.qw.show()
self.faceWidget.show()
self.videoSaver = None
cv2.destroyAllWindows()
self.clicked = False
print("INFO: Streaming paused.")
except Exception as e:
print(str(e))
def getDuration(self):
self.maxTimer = float(self.facePlayer.duration() / 1000)
print(self.maxTimer)
# то что происходит каждый тик таймера
def update(self):
self.counter += 1
# заглушка для считываемого потока
# x = random.randint(0, 100)
# y = random.randint(0, 100)
########################
if not self.fromFile:
# считка с устройства
ch1, ch2 = self.readFromEEG()
# получаем эмоцию
emtn = self.getEmotion(ch1, ch2)
# точки выводятся каждые 100 мс
interval = 100 / 4
if not self.fromFile:
interval = 0.1 / 4
if self.counter >= interval:
interval *= 4
self.counter = 0
# добавляем точки только если их надо считывать
if not self.fromFile:
self.time = self.time.addMSecs(interval * 1000)
self.timings.append(self.time.toString('mm:ss.zzz'))
self.emotions.append(emtn)
self.data1.append(ch1)
self.data2.append(ch2)
# запись в файл
self.f.write(
str(ch1) + "|" + str(ch2) + "|" +
self.time.toString('mm:ss.zzz') + "|" + emtn + "\n")
# все отображается по готовому набору данных и прокручивается каунтером1
if (self.counter1 < len(self.data1)):
self.EmotionLabel.setText("Текущая эмоция: " +
self.emotions[self.counter1])
self.updateGraphs()
self.counter1 += 1
curTime = time.time()
# если все данные уже показаны то стоп
if self.fromFile and (curTime - self.start
) > self.maxTimer and self.counter1 >= len(
self.data1):
self.stop()
def updateGraphs(self):
numbp = 200
# скорость прокрутки - выводятся последние numbp точек
pos = int(self.counter1 - numbp)
if pos < 0:
pos = 0
xdict = dict(enumerate(self.timings[pos:self.counter1]))
self.curve1.setData(self.data1[pos:self.counter1])
self.plot1.getAxis('bottom').setTicks([xdict.items()])
self.plot1.setXRange(0, numbp)
self.curve2.setData(self.data2[pos:self.counter1])
self.plot2.getAxis('bottom').setTicks([xdict.items()])
self.plot2.setXRange(0, numbp)
def getEmotion(self, ch1, ch2):
for emt in self.emotionsList:
isRight = False
if emt.from_strength <= ch1 <= emt.to_strength:
if emt.from_color <= ch2 <= emt.to_color:
isRight = True
if isRight:
return emt.name
return "не определена"
def setGraphs(self):
# self.win.setWindowTitle('pyqtgraph example: Scrolling Plots')
# Use automatic downsampling and clipping to reduce the drawing load
self.plot1.setDownsampling(mode='peak')
self.plot1.setClipToView(True)
self.plot1.setRange(xRange=[0, 100])
self.plot1.setLimits(xMin=0)
self.plot2.setDownsampling(mode='peak')
self.plot2.setClipToView(True)
self.plot2.setRange(xRange=[0, 100])
self.plot2.setLimits(xMin=0)
def openFile(self):
self.vidFileName, _ = QFileDialog.getOpenFileName(
self, "Открыть видео", QDir.homePath(),
"video files (*.avi *.mp4 *.gif)")
if self.vidFileName != '':
self.videoChosed = True
def butter_bandpass(self, lowcut, highcut, fs, order=5):
nyq = 0.5 * fs
low = lowcut / nyq
high = highcut / nyq
b, a = butter(order, [low, high], btype='band')
return b, a
def butter_bandpass_filter(self, data, lowcut, highcut, fs=256, order=5):
b, a = self.butter_bandpass(lowcut, highcut, fs, order=order)
y = lfilter(b, a, data)
return y
def filter(self, data, hi, lo):
fs = np.fft.rfft(data)
q = np.fft.rfftfreq(len(data), 256)
fs[(q > hi)] = 0
fs[(q < lo)] = 0
return np.fft.irfft(fs)
def readFromEEG(self):
n = 26
strArr = np.zeros(n)
pArr = np.zeros(n)
for i in range(0, n):
gotBegin = False
# seek start
while not gotBegin:
# 1
x = self.ser.read()
while int.from_bytes(x, byteorder='big') != 165:
x = self.ser.read()
gotBegin = True
# 2
x = self.ser.read()
gotBegin = gotBegin and int.from_bytes(x,
byteorder='big') == 90
# 3
x = self.ser.read()
gotBegin = gotBegin and int.from_bytes(x, byteorder='big') == 2
# 4
self.ser.read()
def conv2sig(xb, yb):
xi = int.from_bytes(xb, byteorder='big')
yi = int.from_bytes(yb, byteorder='big')
a = format(xi, 'b') + format(yi, 'b')
return int(a, 2)
# 5 and 6
ch1 = conv2sig(self.ser.read(), self.ser.read())
strArr[i] = ch1
# 7 and 8
ch2 = conv2sig(self.ser.read(), self.ser.read())
pArr[i] = ch2
out1 = self.butter_bandpass_filter(strArr, 8, 12)
out2 = self.butter_bandpass_filter(pArr, 12, 30)
# out1 = self.filter(strArr, 8, 12)
# out2 = self.butter_bandpass_filter(strArr, 8, 12)
a1 = np.mean(out1)
a2 = abs(out1.min()) + abs(out1.max())
a3 = out1[len(out1) - 1]
b1 = np.mean(out2)
b2 = abs(out2.min()) + abs(out2.max())
b3 = out2[len(out2) - 1]
return a2, b2
def inputCom(self):
text, ok = QInputDialog.getText(
self, 'Выбор COM порта',
'Введите номер COM порта, к которому подключено устройство:')
if ok:
if sys.platform.startswith('win'):
self.port = 'COM' + text
elif sys.platform.startswith('linux') or sys.platform.startswith(
'cygwin'):
self.port = '/dev/ttyUSB' + text
elif sys.platform.startswith('darwin'):
self.port = '/dev/ttyUSB' + text
else:
raise EnvironmentError('Unsupported platform')
self.ser.port = self.port
if not self.ser.isOpen():
try:
self.ser.open()
except serial.SerialException:
QMessageBox.about(self, "Ошибка!",
"Выберите работающий COM порт!")
def loadFile(self):
path, _ = QFileDialog.getOpenFileName(self, "Открыть файл",
QDir.homePath(),
"Emotion Files (*.emtn)")
if path != '':
self.fromFile = True
f = open(path, 'r', encoding='utf-8', errors='ignore')
allLines = f.readlines()
f.close()
try:
self.vidFileName = allLines[0]
self.vidFileName = self.vidFileName[:-1]
self.faceFileName = allLines[1]
self.faceFileName = self.faceFileName[:-1]
allLines.remove(allLines[0])
allLines.remove(allLines[0])
# reset data for graphse
self.data1 = []
self.data2 = []
self.timings = []
self.emotions = []
self.plot1.getAxis('bottom').setTicks([])
self.plot2.getAxis('bottom').setTicks([])
for line in allLines:
x = line.split('|')
self.data1.append(float(x[0]))
self.data2.append(float(x[1]))
self.timings.append(x[2])
self.emotions.append(x[3])
except Exception as e:
QMessageBox.about(self, "Ошибка!",
"Файл поврежден или неверно сформирован.")
def loadSettings(self):
path, _ = QFileDialog.getOpenFileName(self, "Открыть настройки",
QDir.homePath(),
"txt files (*.txt)")
if path != '':
f = open(path, 'r')
allLines = f.readlines()
f.close()
# считываем данные из файла и записываем эмоции
self.emotions.clear()
for line in allLines:
s = line.rstrip("\r\n")
x = s.split('|')
emotion = Emotion(x[0], int(x[1]), int(x[2]), int(x[3]),
int(x[4]))
self.emotions.append(emotion)
self.settings.loadEmotions(self.emotions)
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Настройки загружены из файла.")
msg.setWindowTitle("Уведомление")
msg.exec_()
self.openSettings()
def openSettings(self):
self.settings.show()
class Frogger(QWidget):
def __init__(self):
super().__init__()
Config.mainWindow = self #odma se postavi koji objekat je mainWindow da bi tamo u Rectangle.py Qlabeli znali gde treba da se nacrtaju. Lose je resenje, al radi bar za testiranje
self.Menu = None # glavni meni
self.InitFlagsAndVariables()
self.scoreboard = Scoreboard(self)
self.highscore = HighScore()
self.highscore.readFromFile()
###############################################
self.videoWidget = QVideoWidget(self)
self.videoWidget.resize(Config.mapSize * Config.gridSize,
Config.mapSize * Config.gridSize + 50)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mediaPlayer.setVideoOutput(self.videoWidget)
self.mediaPlayer.setMedia(
QMediaContent(QUrl(Config.spriteLocation + "Intro.wmv")))
###############################################
self.setWindowState(Qt.WindowNoState)
self.__init_ui__()
self.key_notifier = KeyNotifier()
self.key_notifier.key_signal.connect(self.__update_position__)
self.key_notifier.start()
self.ZevsJavljaVremeQueue = Queue()
self.procUKomZiviZevs = Zeus.PokreniZevsa(
self.ZevsJavljaVremeQueue
) #pokrece proces koji u kju stavlja kakvo vreme treba da bude (sunce, kisa, sneg)
def InitFlagsAndVariables(self):
self.Map = [] # lista lejnova
self.previousWeather = 'n'
self.player1 = None
self.player2 = None
self.player1RectId = -1 # ovo je potrebno za mrezu
self.player2RectId = -1 # ovo je potrebno za mrezu
self.gamePaused = False
self.GameOverBrojac = 0 # za zivote, ako je 2PlayerMode, kad igrac izgubi sve zivote povecava brojac za 1, kad oba izgube sve zivote, brojac je 2 i tad je gameOver
# ako je SinglePlayer mod onda je gameOver ako je brojac 1
self.Level = 1 # za levele
Config.p1Score = 0
Config.p2Score = 0
Config.p1Lives = 5
Config.p2Lives = 5
try:
self.ShutDownHost()
except:
pass
try:
self.ShutDownClient()
except:
pass
self.host = None
self.client = None
self.isHost = False
self.isClient = False
def initVideo(self):
self.videoWidget.show()
self.mediaPlayer.play()
def __init_ui__(self):
self.setWindowTitle('Frogger')
self.setWindowIcon(QtGui.QIcon(Config.spriteLocation +
'iconFrog.png')) #ikonica
self.resize(Config.mapSize * Config.gridSize,
Config.mapSize * Config.gridSize + 50)
self.FixWindowSize()
self.show()
self.initVideo()
q = QTimer()
q.singleShot(6000, self.DisplayMainMenu)
def HsFunkc(self):
self.Menu.HsElementsShow(self.highscore.top3)
#obicna funkcija za fiksiranje velicine prozora
def FixWindowSize(self):
self.setMinimumHeight((Config.mapSize + 1) * Config.gridSize)
self.setMinimumWidth(Config.mapSize * Config.gridSize)
self.setMaximumHeight((Config.mapSize + 1) * Config.gridSize)
self.setMaximumWidth(Config.mapSize * Config.gridSize)
def RemoveVideoIntro(self):
try:
self.mediaPlayer.stop()
self.videoWidget.setParent(None)
self.videoWidget = None
except:
pass
def DisplayMainMenu(self):
self.RemoveVideoIntro()
self.Menu = None
self.Menu = Meni(self, self.SinglePlayerMode, self.TwoPlayerMode,
self.HsFunkc, self.MainMenuHostClick,
self.MainMenuJoinClick, self.CloseWindow)
def PauseGame(self):
self.gamePaused = True
self.updaterGameObjekataThread.PauseGame()
def ResumeGame(self):
self.gamePaused = False
self.updaterGameObjekataThread.ResumeGame()
def RemoveAllGameUIObjects(self):
for lejer, lista in Rectangle.allRectangles.items():
for rect in lista:
rect.RemoveFromScreen()
GameObject.allGameObjects = []
Rectangle.allRectangles = {}
Rectangle.ResetId()
def SinglePlayerMode(self):
self.ClearZeusQueue()
self.Menu.HideMainMenu()
self.DisplayMap(
) #u displayMap se kreira objekat self.updaterGameObjekataThread i zato DisplayMap mora ici prvi
self.createThreadToUpdateGameObjects()
self.startThreadForUpdatingGameObjects()
self.scoreboard.ShowScore()
self.CreatePlayers()
Config.collectLilypadsToAdvanceLevel = 1
def ClearZeusQueue(self):
while not self.ZevsJavljaVremeQueue.empty():
self.ZevsJavljaVremeQueue.get()
def TwoPlayerMode(self, OverNetworkGame=False):
self.ClearZeusQueue()
self.Menu.HideMainMenu()
if not OverNetworkGame: #kad je preko mreze onda updateovanje krece kad klijent bude spreman
self.createThreadToUpdateGameObjects()
self.startThreadForUpdatingGameObjects()
self.DisplayMap(TwoPlayers=True)
self.scoreboard.ShowScores()
self.CreatePlayers(TwoPlayers=True)
Config.collectLilypadsToAdvanceLevel = 3
def MainMenuHostClick(self):
self.HostServer(Config.serverAddress, Config.serverPort)
def MainMenuJoinClick(self):
#self.Menu.JoinWidgetHide()
self.setFocus()
#ovde sacuvamo ip adresu i port u fajl. da kad se sledeci put upali igra da odma ucita tu ipadresu i port
try:
with open(Config.lastIp_filename, "w") as f:
f.write(str(self.Menu.ipAddr) + ":" + str(self.Menu.port))
except:
pass
self.JoinServer(self.Menu.ipAddr, int(self.Menu.port))
def CreatePlayers(self, TwoPlayers=False):
self.player1 = Frog(Config.player1StartPosition[0],
Config.player1StartPosition[1], self.GameOverCheck,
self.updateP1Score, self.createGreenLives)
self.player1RectId = self.player1.id
if TwoPlayers:
self.player2 = Frog(Config.player2StartPosition[0],
Config.player2StartPosition[1],
self.GameOverCheck,
self.updateP2Score,
self.createPinkLives,
isPlayerTwo=True)
self.player2RectId = self.player2.id
def updateP1Score(self, newScore):
self.scoreboard.updateP1Score(newScore)
if self.isHost:
self.host.SendToClient(Config.network_updateGameScoreAndLives +
":" + "P1S_" +
str(newScore)) #P2L => Player 2 Lives
def updateP2Score(self, newScore):
self.scoreboard.updateP2Score(newScore)
if self.isHost:
self.host.SendToClient(Config.network_updateGameScoreAndLives +
":" + "P2S_" +
str(newScore)) #P2L => Player 2 Lives
def createPinkLives(self, lives):
self.scoreboard.CreatePinkLives(lives)
if self.isHost:
self.host.SendToClient(Config.network_updateGameScoreAndLives +
":" + "P2L_" +
str(lives)) #P2L => Player 2 Lives
def createGreenLives(self, lives):
self.scoreboard.CreateGreenLives(lives)
if self.isHost:
self.host.SendToClient(Config.network_updateGameScoreAndLives +
":" + "P1L_" +
str(lives)) #P1L => Player 2 Lives
def DisplayMap(self, TwoPlayers=False):
self.Map.append(Lane.GenerateSafetyLane()) #prvi je uvek sejf lejn
self.GenerateLanes('Road') #fja da generise lejnove za put
#self.Map.append(Lane.GenerateSafetyLane())
##ovaj ce da bude uvek tu da bi se moglo duze igrati
##lejn sa zivotom
self.Map.append(Lane.GenerateSafetyLaneWithDeus())
self.GenerateLanes('Water') #fja da generise lejnove za reku
if TwoPlayers:
self.Map.append(Lane.GenerateFinalLane(
self.LevelPassed)) # zadnji je uvek finalLane
else:
self.Map.append(
Lane.GenerateFinalLane(
self.LevelPassed,
lilyPadPattern=Config.lilypadPatternBO5Standard)
) # zadnji je uvek finalLane
def GameOverCheck(self, isPlayerTwo):
#fja koja se poziva kada igrac ima 0 zivota, prosledjuje se igracima kroz konstruktor
self.GameOverBrojac += 1
if self.player1 != None and self.player2 != None:
if self.GameOverBrojac == 1:
if isPlayerTwo:
self.highscore.checkIfHighScore(self.player2.playerName,
self.player2.score)
self.player2.RemoveFromScreen()
self.player2 = None
Config.p2Lives = 0
else:
self.highscore.checkIfHighScore(self.player1.playerName,
self.player1.score)
self.player1.RemoveFromScreen()
self.player1 = None
Config.p1Lives = 0
elif self.player1 != None:
self.highscore.checkIfHighScore(self.player1.playerName,
self.player1.score)
self.GameOver()
elif self.player2 != None:
self.highscore.checkIfHighScore(self.player2.playerName,
self.player2.score)
self.GameOver()
def GameOver(self):
# javimo klijentu da bi se vratio na meni
if self.isHost:
self.host.SendToClient(Config.network_ConnectionError)
#fja koja se poziva kad su svi igraci igraci ostali bez zivota
self.stopThreadForUpdatingObjects()
self.DeleteMap(deleteP1=True, deleteP2=True)
self.Menu.ShowMainMenu()
Lane.ResetLaneStartingIndex()
self.scoreboard.HideScores()
self.Menu.kisa.hide()
self.Menu.sneg.hide()
self.scoreboard.CreateGreenLives(0)
self.scoreboard.CreatePinkLives(0)
self.InitFlagsAndVariables()
def ShutDownHost(self):
if self.host != None:
print("gasim hosta")
self.host.StopHosting()
self.isHost = False
self.host = None
def ShutDownClient(self):
if self.client != None:
self.client.StopClienting()
self.isClient = False
self.client = None
def LevelPassed(self):
#fja koja se poziva kad su svih 5 Lilypada popunjena, prosledjuje se u konstruktoru, prvo finalLejnu pa samim objektima
self.Level += 1
Lane.ResetLaneStartingIndex()
self.GameOverBrojac = 0
self.DeleteMap()
if self.player1 != None and self.player2 != None:
Config.p1Score = self.player1.score
Config.p2Score = self.player2.score
Config.p1Lives = self.player1.lives
Config.p2Lives = self.player2.lives
self.DisplayMap(TwoPlayers=True)
self.CreatePlayers(TwoPlayers=True)
elif self.player1 != None:
Config.p1Score = self.player1.score
Config.p1Lives = self.player1.lives
self.DisplayMap()
self.CreatePlayers()
elif self.player2 != None:
Config.p2Score = self.player2.score
Config.p2Lives = self.player2.lives
self.DisplayMap()
self.CreatePlayers(TwoPlayers=True)
self.player1.RemoveFromScreen()
self.player1 = None
if self.isHost and self.player2 != None:
self.SendClientToReplicateObjects()
def DeleteMap(self, deleteP1=False, deleteP2=False):
if deleteP1:
try:
self.player1.RemoveFromScreen()
self.player1 = None
except:
print('P1 vec postavljen na None')
if deleteP2:
try:
self.player2.RemoveFromScreen()
self.player2 = None
except:
print('P2 vec postavljen na None')
for lane in self.Map:
for obs in lane.obstacles:
obs.RemoveFromScreen()
lane.obstacles.clear()
lane.RemoveFromScreen()
for layer, listOfRectanglesInLayer in Rectangle.allRectangles.items():
for rect in listOfRectanglesInLayer:
rect.RemoveFromScreen()
listOfRectanglesInLayer.clear()
self.Map.clear()
def DisplayTestMap(self):
Lane.ResetLaneStartingIndex()
self.Map.append(Lane.GenerateSafetyLane())
self.Map.append(Lane.GenerateEasyLane())
self.Map.append(Lane.GenerateEasyLane())
self.Map.append(Lane.GenerateEasyLane())
self.Map.append(Lane.GenerateSafetyLane())
self.Map.append(Lane.GenerateFinalLane())
self.Map.append(
Lane.GenerateFinalLane(lilyPadPattern=Config.lilypadPatternBO3))
self.Map.append(
Lane.GenerateFinalLane(lilyPadPattern=Config.lilypadPatternBO5V2))
self.Map.append(Lane.GenerateFinalLane(randomPatternBO5=True))
def keyPressEvent(self, event):
if not event.isAutoRepeat():
self.key_notifier.add_key(event.key())
def __update_position__(self, key):
if not self.isClient:
if key == Qt.Key_Escape and self.gamePaused:
self.ResumeGame()
elif key == Qt.Key_Escape and not self.gamePaused:
self.PauseGame()
if self.isClient: #ako sam klijent onda pored pomeranja zabe, hocu da posaljem INPUT serveru
if key == Qt.Key_Right:
self.client.SendToServer(Config.network_inputKlijentaPrefix +
"DESNO")
elif key == Qt.Key_Down:
self.client.SendToServer(Config.network_inputKlijentaPrefix +
"DOLE")
elif key == Qt.Key_Up:
self.client.SendToServer(Config.network_inputKlijentaPrefix +
"GORE")
elif key == Qt.Key_Left:
self.client.SendToServer(Config.network_inputKlijentaPrefix +
"LEVO")
if key == Qt.Key_T:
for go in GameObject.allGameObjects:
print(str(go.id) + "__" + str(go.loadedSprite))
if self.gamePaused: #sve sto je ispod nece biti odradjeno kad je game pauziran
return
if self.player1 != None:
self.player1.KeyPress(key)
if self.player2 != None:
self.player2.KeyPress(key)
def CloseWindow(self):
# OVDE TREBA DA SE POZOVE KOD KOJI CE DA ZAUSTAVI ZEVSA
# (ako uopste postoji neko toliko jak da zaustavi zevsa)
try:
self.procUKomZiviZevs.terminate()
except:
pass
try:
self.updaterGameObjekataThread.updaterThreadWork = False # self.updaterGameObjekataThread se kreira samo kad pocne IGRA. Ako budes na meniju i nista ne radis nece se kreirati
except:
pass
self.key_notifier.die()
def closeEvent(self, event):
self.CloseWindow()
def createThreadToUpdateGameObjects(self):
self.updaterGameObjekataThread = GOUpdater()
self.updaterGameObjekataThread.nekiObjekat.connect(
self.updateAllGameObjects)
#OVO (thread koji updateuje objekte) SE POKRECE KAD KLIJENT BUDE SPREMAN (nakon sto preuzme sve objekte i nacrta ih na ekranu), ili kad pocne neki od lokalnih game modova
#self.updaterGameObjekataThread.start()
def startThreadForUpdatingGameObjects(self):
self.updaterGameObjekataThread.start()
def stopThreadForUpdatingObjects(self):
try: #na klijentu ovaj objekat za updateovanje ce biti null
self.updaterGameObjekataThread.updaterThreadWork = False
except:
pass
def updateAllGameObjects(self, dummy): #callback funkcija
for gameObject in GameObject.allGameObjects:
gameObject.update()
# ako je instanca server i postoje gameobjekti onda da salje klijentu pozicije tih objekata
if self.isHost and len(GameObject.allGameObjects) > 0:
self.SendRectPositionUpdateToClient()
if not self.ZevsJavljaVremeQueue.empty():
self.updateWeather(self.ZevsJavljaVremeQueue.get())
else:
return
def updateWeather(self, newWeather):
if self.isHost:
self.host.SendToClient(Config.network_updateWeatherInfo + ":" +
newWeather)
if newWeather == 'k':
if self.previousWeather == 'k':
self.ZaustaviKisu()
elif self.previousWeather == 's':
self.ZaustaviSneg()
self.PokreniKisu()
elif newWeather == 's':
if self.previousWeather == 'k':
self.ZaustaviKisu()
elif self.previousWeather == 's':
self.ZaustaviSneg()
self.PokreniSneg()
elif newWeather == 'n':
if self.previousWeather == 'k':
self.ZaustaviKisu()
elif self.previousWeather == 's':
self.ZaustaviSneg()
self.previousWeather = newWeather
def createLanes(self, niz, type):
#funkcija koja generise lejnove u zavisnosti od prosledjenog niza i karaktera u njemu
if type == 'Road':
for letter in niz:
if letter == 'e':
self.Map.append(Lane.GenerateEasyLane())
elif letter == 'm':
self.Map.append(Lane.GenerateMediumLane())
elif letter == 'h':
self.Map.append(Lane.GenerateHardLane())
elif type == 'Water':
for letter in niz:
if letter == 'e':
self.Map.append(Lane.GenerateEasyWaterLane())
elif letter == 'm':
self.Map.append(Lane.GenerateMediumWaterLane())
elif letter == 'h':
self.Map.append(Lane.GenerateHardWaterLane())
elif type == 'Random':
for letter in niz:
if letter == 's': # safe lane
self.Map.append(Lane.GenerateSafetyLane())
elif letter == 'e': # easy lane, if generated -1 -> easyWaterLane if 1 easyTrafficLane, isto vazi za ostale samo se menja tezina s,m,h...
if [-1, 1][randrange(2)] == -1:
self.Map.append(Lane.GenerateEasyWaterLane())
else:
self.Map.append(Lane.GenerateEasyLane())
elif letter == 'm':
if [-1, 1][randrange(2)] == -1:
self.Map.append(Lane.GenerateMediumWaterLane())
else:
self.Map.append(Lane.GenerateMediumLane())
elif letter == 'h':
if [-1, 1][randrange(2)] == -1:
self.Map.append(Lane.GenerateHardWaterLane())
else:
self.Map.append(Lane.GenerateHardLane())
def GenerateLanes(self, type):
# 6 lejnova, fja u kojoj se odlucuje tezina po levelima, moze da se menja po volji
nizTezine = []
if self.Level <= 2:
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
elif self.Level > 2 and self.Level <= 4:
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
type = 'Random'
elif self.Level > 4 and self.Level <= 6:
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
elif self.Level > 6 and self.Level <= 8:
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('e')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
type = 'Random'
elif self.Level > 8 and self.Level <= 10:
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
elif self.Level > 10 and self.Level <= 12:
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
type = 'Random'
elif self.Level > 12 and self.Level <= 14:
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
elif self.Level > 12 and self.Level <= 14:
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('m')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
type = 'Random'
elif self.Level > 14 and self.Level <= 16:
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
elif self.Level > 16:
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
nizTezine.append('h')
type = 'Random'
shuffle(nizTezine) #permutuj niz da lejnovi budu random
self.createLanes(nizTezine, type)
def PokreniKisu(self): #Fja da se prikaze kisa
self.Menu.PrikaziPadavinu('kisa')
for lane in self.Map:
if lane.laneType == Config.laneTypeWater:
lane.ChangeSpeed(
Config.speedChange) #brzina drveca se povecava kad je kisa
elif lane.laneType == Config.laneTypeTraffic or lane.laneType == Config.laneTypeTrafficTop or lane.laneType == Config.laneTypeTrafficBottom:
lane.ChangeSpeed(-Config.speedChange
) #brzina automobila se smanjuje kad je kisa
def PokreniSneg(self): #Fja da se prikaze sneg
self.Menu.PrikaziPadavinu('sneg')
for lane in self.Map:
if lane.laneType == Config.laneTypeWater:
lane.ChangeSpeed(-Config.speedChange
) #brzina drveca se smanjuje kad je sneg
elif lane.laneType == Config.laneTypeTraffic or lane.laneType == Config.laneTypeTrafficTop or lane.laneType == Config.laneTypeTrafficBottom:
lane.ChangeSpeed(Config.speedChange
) #brzina automobila se povecava kad je sneg
def ZaustaviKisu(self): #Fja da se zaustavi kisa
self.Menu.SakrijPadavinu('kisa')
for lane in self.Map:
if lane.laneType == Config.laneTypeWater:
lane.ChangeSpeed(
-Config.speedChange
) #obrnuto, ako smo bili povecali brzinu drveca kad je kisa pocela, sad je smanjujemo, vracamo na default
elif lane.laneType == Config.laneTypeTraffic or lane.laneType == Config.laneTypeTrafficTop or lane.laneType == Config.laneTypeTrafficBottom:
lane.ChangeSpeed(
Config.speedChange
) #obrnuto, ako smo bili smanjili brzinu automobila kad je kisa pocela, sad je povecavamo, vracamo na default
def ZaustaviSneg(self): #Fja da se zaustavi sneg
self.Menu.SakrijPadavinu('sneg')
for lane in self.Map:
if lane.laneType == Config.laneTypeWater:
lane.ChangeSpeed(
Config.speedChange
) #obrnuto, ako smo bili smanjili brzinu drveca kad je poceo sneg, sad je povecavamo, vracamo na default
elif lane.laneType == Config.laneTypeTraffic or lane.laneType == Config.laneTypeTrafficTop or lane.laneType == Config.laneTypeTrafficBottom:
lane.ChangeSpeed(
-Config.speedChange
) #obrnuto, ako smo bili povecali brzinu automobila kad je poceo sneg, sad je smanjujemo, vracamo na default
################################################################################
#FUNKCIJE ISPOD SE KORISTE SAMO ZA MULITPLAYER
################################################################################
def HostServer(self, address, port):
self.isHost = True
self.host = Host(address, port)
self.host.receiveCallBack.connect(self.ReceiveFromClient)
self.host.start()
def JoinServer(self, address, port):
self.isClient = True
self.client = Client(address, port)
self.client.receiveCallBack.connect(self.ReceiveFromServer)
self.client.start()
def SendClientToReplicateObjects(self):
self.host.SendToClient(Config.network_kreirajSveObjekteNaKlijentu +
":" + self.CreateInitObjectsString())
# ovo ce biti pozvano kad server primi poruku od klijenta
def ReceiveFromClient(self, data):
# print("Primio od klijenta: " + str(data))
if data == Config.network_clientIsReady: # kad primi ovo znaci da se klijent povezao
self.TwoPlayerMode(OverNetworkGame=True)
self.player2.keyBoardInputEnabled = False
self.SendClientToReplicateObjects(
) #da ne generise updater svaki put kad se predje level, vec samo incijalno kad se uspostavi veza
elif data == Config.network_potvrdaKlijentaDaJeNapravioSveObjekte and self.Level == 1: # klijent je potvrdio da je napravio sve objekte i sad pokrecemo igru (pravimo i pokrecemo thread koji updateuje igru)
self.createThreadToUpdateGameObjects()
self.startThreadForUpdatingGameObjects()
elif Config.network_inputKlijentaPrefix in data and self.player2 != None: #ovo da li je igrac razlicit od None je ustvari provera da li je ziv
if Config.network_inputKlijentaPrefix + "DESNO" == data:
self.player2.GoRight()
elif Config.network_inputKlijentaPrefix + "DOLE" == data:
self.player2.GoDown()
elif Config.network_inputKlijentaPrefix + "GORE" == data:
self.player2.GoUp()
elif Config.network_inputKlijentaPrefix + "LEVO" == data:
self.player2.GoLeft()
elif Config.network_ConnectionError == data:
print("Klijent je otiso :(")
self.ResetGameStateOnError()
# ovo ce biti pozvano kad klijent primi poruku od servera
def ReceiveFromServer(self, data):
#print("Primio od servera: " + str(data))
if data == Config.network_serverWelcomeMsg: # znaci da smo se uspesno povezali sa serverom i inicijalizujemo gejm
self.InitNetworkGame()
elif Config.network_kreirajSveObjekteNaKlijentu in data:
self.GenerateObjects(data.split(":")[1])
self.client.SendToServer(
Config.network_potvrdaKlijentaDaJeNapravioSveObjekte)
elif Config.network_updateSveObjekteNaKlijentu in data:
self.UpdateObjectsPosition(data.split(":")[1])
elif Config.network_updateGameScoreAndLives in data:
#ako ovde udje PAYLOAD moze da izgleda ovako:
#P2L_3
#P1S_2
#P2S_4
#P1L_1
payload = data.split(":")[1]
player, scoreOrLives = payload.split('_')
#print(str(payload))
if "P1" in player:
if "S" in player:
self.updateP1Score(scoreOrLives)
elif "L" in player:
self.createGreenLives(int(scoreOrLives))
elif "P2" in player:
if "S" in player:
self.updateP2Score(scoreOrLives)
elif "L" in player:
self.createPinkLives(int(scoreOrLives))
elif Config.network_updateWeatherInfo in data:
self.updateWeather(data.split(":")[1])
elif Config.network_ConnectionError == data:
self.ResetGameStateOnError()
#ovo se poziva na klijentu.
def InitNetworkGame(self):
self.TwoPlayerMode(
OverNetworkGame=True
) #nije potrebno ovo True, al da se dzabe nebi pravio thread koji se ne koristi :D
#sklanjamo sve objekte, jer ce nam server poslati sta je on generisao (velicine, pozicije, sprajtove)
for go in GameObject.allGameObjects:
go.RemoveFromScreen()
GameObject.allGameObjects.clear()
#klijent javi serveru da je spreman (spreman da primi podatke o svim objektima)
self.client.SendToServer(Config.network_clientIsReady)
#poziva se ako dodje do greske prilikom komunikacije sa klijentom
def ResetGameStateOnError(self):
self.RemoveAllGameUIObjects()
self.GameOver()
#poziva se samo na serveru
def SendRectPositionUpdateToClient(self):
self.host.SendToClient(Config.network_updateSveObjekteNaKlijentu +
":" + self.CreateUpdateObjectsString())
#ova metoda moze ici u GameObject Klasu
def CreateInitObjectsString(self):
objektiUString = []
for go in GameObject.allGameObjects: #saljemo podatke koji su potrebni da bi se napravili objekti na klijentu
objektiUString.append(
str(go.id) + "%" + go.loadedSprite + "%" + str(go.x) + "%" +
str(go.y) + "%" + str(go.w) + "%" + str(go.h))
return "#".join(objektiUString)
# ova metoda moze ici u GameObject Klasu
def CreateUpdateObjectsString(self):
objektiUString = []
for go in GameObject.allGameObjects: #saljemo podatke koji su potrebni da bi se updateovale pozicije objekata na klijentu
#optimizovano, ne saljem update za sve gameObjecte vec samo one koji su u lejeru prepreke i imaju neku brzinu
if go.layer == Config.layerPrepreke and go.speed != 0:
objektiUString.append(
str(go.id) + "%" + str(go.x) + "%" + str(go.y))
elif go.layer == Config.layerZabe or go.layer == Config.layerLilypad: #igraci i lokvanji mogu da promene sprite i zato saljem i sprite :D
objektiUString.append(
str(go.id) + "%" + str(go.x) + "%" + str(go.y) + "%" +
str(go.loadedSprite))
# ovo je dodato ako neki od igraca umre da ga klijent skloni sa ekrana (sprite se stavi na prazan string)
if self.player1 == None and self.player1RectId != -1:
objektiUString.append(
str(self.player1RectId) + "%" + str(0) + "%" + str(0) +
"%DEAD")
self.player1RectId = -1
if self.player2 == None and self.player2RectId != -1:
objektiUString.append(
str(self.player2RectId) + "%" + str(0) + "%" + str(0) +
"%DEAD")
self.player2RectId = -1
return "#".join(objektiUString)
#ova funkcija se poziva na klijentu, da napravi objekte iste kao sto su na serveru. Pozove se samo na pocetku
def GenerateObjects(self, data):
for layer, listOfRects in Rectangle.allRectangles.items():
for rect in listOfRects:
rect.RemoveFromScreen()
listOfRects.clear()
objs = data.split("#")
Rectangle.ResetId()
for obj in objs:
objData = obj.split("%")
r = Rectangle(float(objData[2]),
float(objData[3]),
int(objData[4]),
int(objData[5]),
objData[1],
layer=objData[0],
forceId=int(objData[0]))
r.Show()
#ova funkcija se poziva na klijentu, sluzi za updateovanje (samo X i Y kordinate) svih rectanglova na klijentu.
#server ce ovo slati klijentu svaki frejm (30 puta u sekundi)
def UpdateObjectsPosition(self, data):
objs = data.split("#")
dictObj = {}
for obj in objs:
objData = obj.split("%")
if len(objData) == 4:
dictObj[objData[0]] = (float(objData[1]), float(objData[2]),
objData[3])
elif len(objData) == 3:
dictObj[objData[0]] = (float(objData[1]), float(objData[2]))
for go in GameObject.allGameObjects:
strId = str(go.id)
if strId in dictObj.keys():
go.SetPosition(dictObj[strId][0], dictObj[strId][1])
if len(dictObj[strId]
) == 3: #ako je 3 znaci da imamo i sprite poslat
go.ChangeSprite(dictObj[strId][2])
class QtPlayer(QMainWindow):
pRate = 1.0
def __init__(self):
super().__init__()
# 设置窗口
self.setGeometry(300, 300, 800, 600 + 96)
self.setWindowTitle('Player')
self.setFixedSize(800, 600 + 96)
# 设置滑动条
self.slider = QSlider(QtCore.Qt.Horizontal, self)
self.slider.setGeometry(10, 640, 800 - 20, 20)
self.slider.setRange(0, 100)
self.slider.sliderPressed.connect(self.SlideChanged)
self.slider.valueChanged.connect(self.setClock) # 设置时间条
self.slider.show()
# 设置按钮
self.btn = QPushButton('暂停', self)
self.btn.clicked.connect(self.handleButton)
self.btn.resize(self.btn.sizeHint())
self.btn.move(700 / 2, 600 + 60)
self.btn1 = QPushButton('播放', self)
self.btn1.clicked.connect(self.handleButton1)
self.btn1.resize(self.btn1.sizeHint())
self.btn1.move(700 / 2, 600 + 60)
self.btn1.hide()
self.forward = QPushButton('快进', self)
self.forward.clicked.connect(self.handleForward)
self.forward.resize(self.btn.sizeHint())
self.forward.move(700 / 2 + 70, 600 + 60)
self.back = QPushButton('快退', self)
self.back.clicked.connect(self.handleBack)
self.back.resize(self.btn.sizeHint())
self.back.move(700 / 2 - 70, 600 + 60)
# 设置菜单
self.createMenu()
# 多媒体播放器
self.vw = QVideoWidget(self)
self.vw.setGeometry(QtCore.QRect(0, 30, 800, 600))
self.vw.show()
# 视频读入
self.player = QMediaPlayer(self)
self.player.setVideoOutput(self.vw) # 视频播放输出的widget，就是上面定义的
self.player.positionChanged.connect(self.PlaySlide)
self.player.durationChanged.connect(self.MediaTime)
# 音量条（音量初始化需要player定义好了才能设置）
self.createVol()
# 时间条 （播放时间/视频时长）
self.clock = QLabel(self)
self.clock.setText("00:00/00:00")
self.clock.setGeometry(550, 660, 80, 30)
# 进入主循环
self.show()
def createVol(self): # 音量调节
self.volLabel = QLabel(self)
self.volLabel.setText("音量")
self.volLabel.setGeometry(100, 660, 30, 30)
self.volSlider = QSlider(QtCore.Qt.Horizontal, self)
self.volSlider.setGeometry(130, 660, 80, 30)
self.volSlider.setRange(0, 100)
self.volSlider.valueChanged.connect(self.volChanged)
self.volSlider.setValue(80) # 默认80%的音量
self.volSlider.show()
def setClock(self):
tmp1 = self.player.position()
tmp2 = self.player.duration()
self.clock.setText("%d:%d/%d:%d" %
(tmp1 / 1000 / 60, tmp1 / 1000 % 60,
tmp2 / 1000 / 60, tmp2 / 1000 % 60))
def volChanged(self): # 音量调节
self.player.setVolume(self.volSlider.value())
def SlideChanged(self): # 滚动条手动改变
self.player.setPosition(self.slider.value() * 1000)
def PlaySlide(self, val): # 设置滚动条值
self.slider.setValue(int(val / 1000))
def MediaTime(self, time): # 设置滚动条范围
self.slider.setValue(0)
self.time = self.player.duration() / 1000
self.slider.setRange(0, int(self.time))
def handleButton1(self): # 播放
self.player.play()
self.btn1.hide()
self.btn.show()
def handleButton(self): # 暂停
self.player.pause()
self.btn.hide()
self.btn1.show()
def handleBack(self): # 慢放
if self.pRate > 0.5:
self.pRate = self.pRate - 0.5
self.player.setPlaybackRate(self.pRate)
def handleForward(self): # 快放
if self.pRate < 1.5:
self.pRate = self.pRate + 0.5
self.player.setPlaybackRate(self.pRate)
def createMenu(self): #创建菜单
self.fileMenu()
def fileMenu(self):
menu = self.menuBar().addMenu('文件(&F)')
openfile = menu.addAction('打开(&O)', self.openfile_triggered)
quitfile = menu.addAction('退出(&Q)', self.quitfile_triggered)
openfile.setShortcut("Ctrl+O")
quitfile.setShortcut("Ctrl+Q")
def openfile_triggered(self):
self.player.setMedia(QMediaContent(
QFileDialog.getOpenFileUrl()[0])) # 选取视频文件
self.player.play()
"""
filename, fileType = QFileDialog.getOpenFileName(self, "打开文件", './', "Video Files(*.mp4)")
if len(fileType) != 0:
self.player.setMedia(QMediaContent(QUrl.fromLocalFile(filename))) # 选取视频文件
self.player.play() # 播放视频
"""
def quitfile_triggered(self):
self.close()
class MainWindow(QWidget):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.playlistView = QListView()
self.switch_status = 2
self.video_widget = QVideoWidget()
self.playlist = QMediaPlaylist()
self.model = PlaylistModel(self.playlist)
self.titleBar = TitleBar(self)
self.currentTimeLabel = QLabel()
self.timeSlider = QSlider()
self.totalTimeLabel = QLabel()
self.mediaPlayer = QMediaPlayer()
self.open_btn = QPushButton('Open File')
self.play_btn = QPushButton()
self.prev_btn = QPushButton()
self.stop_btn = QPushButton()
self.next_btn = QPushButton()
self.switch_media_widgets_btn = QPushButton()
self.pseudo_label = QLabel()
self.vol_label = QLabel()
self.volume_slider = Slider(Qt.Horizontal)
self.gui()
self.set_children_focus_policy(Qt.NoFocus)
def gui(self):
self.currentTimeLabel.setMinimumSize(QSize(80, 0))
self.currentTimeLabel.setAlignment(Qt.AlignRight | Qt.AlignTrailing | Qt.AlignVCenter)
self.timeSlider.setOrientation(Qt.Horizontal)
self.totalTimeLabel.setMinimumSize(QSize(80, 0))
self.totalTimeLabel.setAlignment(Qt.AlignLeading | Qt.AlignLeft | Qt.AlignVCenter)
self.playlistView.setAcceptDrops(True)
self.playlistView.setProperty("showDropIndicator", True)
self.playlistView.setDragDropMode(QAbstractItemView.DropOnly)
self.playlistView.setAlternatingRowColors(True)
self.playlistView.setUniformItemSizes(True)
self.setWindowFlags(Qt.FramelessWindowHint)
self.setWindowTitle('Media Player')
self.titleBar.label.setText('Media Player')
self.setWindowIcon(QIcon('icon_png/media_player.png'))
self.setGeometry(600, 200, 850, 600)
self.timeSlider.setRange(0, 0)
self.play_btn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.prev_btn.setIcon(self.style().standardIcon(QStyle.SP_MediaSkipBackward))
self.next_btn.setIcon(self.style().standardIcon(QStyle.SP_MediaSkipForward))
self.stop_btn.setIcon(self.style().standardIcon(QStyle.SP_MediaStop))
self.switch_media_widgets_btn.setIcon(self.style().standardIcon(QStyle.SP_FileDialogDetailedView))
self.vol_label.setText("")
self.vol_label.setPixmap(QPixmap("icon_png/speaker-volume.png"))
self.currentTimeLabel.setText("00:00")
self.totalTimeLabel.setText("00:00")
self.volume_slider.setValue(self.mediaPlayer.volume())
self.mediaPlayer.setVideoOutput(self.video_widget)
self.mediaPlayer.setPlaylist(self.playlist)
self.playlistView.setModel(self.model)
self.video_widget.hide()
sizegrip = QSizeGrip(self)
self.setAcceptDrops(True)
inner_h_box = QHBoxLayout()
inner_h_box.addWidget(self.prev_btn)
inner_h_box.addWidget(self.stop_btn)
inner_h_box.addWidget(self.next_btn)
vol_h_box = QHBoxLayout()
vol_h_box.addWidget(self.vol_label, 0)
vol_h_box.addWidget(self.volume_slider, 1)
h_box = QHBoxLayout()
h_box.addWidget(self.open_btn)
h_box.addWidget(self.play_btn, 0)
h_box.addLayout(inner_h_box, 0)
h_box.addWidget(self.switch_media_widgets_btn, 0)
h_box.addWidget(self.pseudo_label, 1)
h_box.addLayout(vol_h_box, 0)
h_box.addWidget(sizegrip, 0, Qt.AlignBottom | Qt.AlignRight)
video_slider_h_box = QHBoxLayout()
video_slider_h_box.addWidget(self.currentTimeLabel)
video_slider_h_box.addWidget(self.timeSlider)
video_slider_h_box.addWidget(self.totalTimeLabel)
v_box = QVBoxLayout()
v_box.addWidget(self.titleBar, 0)
v_box.addWidget(self.video_widget, 1)
v_box.addWidget(self.playlistView, 1)
v_box.addLayout(video_slider_h_box, 0)
v_box.addLayout(h_box, 0)
inner_h_box.setContentsMargins(20, 0, 10, 0)
vol_h_box.setContentsMargins(0, 0, 20, 0)
h_box.setContentsMargins(20, 0, 0, 0)
v_box.setContentsMargins(0, 0, 0, 0)
video_slider_h_box.setSpacing(10)
h_box.setSpacing(0)
v_box.setSpacing(0)
self.setLayout(v_box)
self.enabler()
# connections
self.open_btn.clicked.connect(self.open_file)
self.play_btn.clicked.connect(self.play_media)
self.stop_btn.clicked.connect(self.stop_media)
self.prev_btn.pressed.connect(self.play_prev)
self.next_btn.pressed.connect(self.play_next)
self.switch_media_widgets_btn.pressed.connect(self.switch_media)
self.playlist.currentIndexChanged.connect(self.playlist_position_changed)
selection_model = self.playlistView.selectionModel()
selection_model.selectionChanged.connect(self.playlist_selection_changed)
self.mediaPlayer.durationChanged.connect(self.update_duration)
self.mediaPlayer.positionChanged.connect(self.update_position)
self.timeSlider.valueChanged.connect(self.mediaPlayer.setPosition)
self.mediaPlayer.stateChanged.connect(self.media_state)
self.mediaPlayer.volumeChanged.connect(self.volume_changed)
self.volume_slider.valueChanged.connect(self.set_volume)
def set_children_focus_policy(self, policy):
def recursive_set_child_focus_policy(parent_q_widget):
for childQWidget in parent_q_widget.findChildren(QWidget):
childQWidget.setFocusPolicy(policy)
recursive_set_child_focus_policy(childQWidget)
recursive_set_child_focus_policy(self)
def enabler(self, state=False):
if state is False:
self.play_btn.setEnabled(False)
self.prev_btn.setEnabled(False)
self.stop_btn.setEnabled(False)
self.next_btn.setEnabled(False)
else:
self.play_btn.setEnabled(True)
self.stop_btn.setEnabled(True)
self.prev_btn.setEnabled(True)
self.next_btn.setEnabled(True)
def switch_media(self):
if self.switch_status == 0:
self.video_widget.hide()
self.playlistView.show()
self.switch_status = 1
self.switch_media_widgets_btn.setEnabled(True)
elif self.switch_status == 1:
self.video_widget.show()
self.playlistView.hide()
self.switch_status = 0
self.switch_media_widgets_btn.setEnabled(True)
else:
self.video_widget.hide()
self.playlistView.show()
self.switch_media_widgets_btn.setEnabled(False)
def play_media(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
self.ui_handler()
def ui_handler(self):
if not self.playlist.isEmpty():
self.enabler(True)
file_path = QFileInfo(self.mediaPlayer.currentMedia().canonicalUrl().toString()).fileName()
ext = os.path.splitext(file_path)[-1].lower()
audio_ext = ['.flac', '.mp3']
video_ext = ['.mp4', '.m4a', '.mov', '.flv', 'avi', '3gp', '.mkv', '.wmv']
if ext in audio_ext:
self.switch_status = 2
self.switch_media()
if self.isFullScreen():
self.fullscreen()
elif ext in video_ext:
self.switch_status = 1
self.switch_media()
self.setWindowTitle(file_path + ' - Media Player')
self.titleBar.label.setText(file_path + ' - Media Player')
def stop_media(self):
if self.mediaPlayer.state() != QMediaPlayer.StoppedState:
self.mediaPlayer.stop()
self.setWindowTitle('Media Player')
self.titleBar.label.setText('Media Player')
def fullscreen(self):
if self.switch_status == 2 or self.isFullScreen():
self.titleBar.show()
self.timeSlider.show()
self.currentTimeLabel.show()
self.totalTimeLabel.show()
self.volume_slider.show()
self.open_btn.show()
self.play_btn.show()
self.prev_btn.show()
self.stop_btn.show()
self.next_btn.show()
self.switch_media_widgets_btn.show()
self.pseudo_label.show()
self.vol_label.show()
self.showNormal()
else:
self.titleBar.hide()
self.timeSlider.hide()
self.currentTimeLabel.hide()
self.totalTimeLabel.hide()
self.volume_slider.hide()
self.open_btn.hide()
self.play_btn.hide()
self.prev_btn.hide()
self.stop_btn.hide()
self.next_btn.hide()
self.switch_media_widgets_btn.hide()
self.pseudo_label.hide()
self.vol_label.hide()
self.showFullScreen()
def mouseDoubleClickEvent(self, event: QMouseEvent):
event.accept()
if event.button() == Qt.LeftButton:
self.fullscreen()
def media_state(self):
os_sleep = WindowsInhibitor()
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.play_btn.setIcon(self.style().standardIcon(QStyle.SP_MediaPause))
if os.name == 'nt':
os_sleep = WindowsInhibitor()
os_sleep.inhibit()
else:
self.play_btn.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
if os_sleep:
os_sleep.uninhibit()
def play_next(self):
self.playlist.next()
def media_seek(self, seek):
if not self.playlist.isEmpty():
player = self.mediaPlayer
if (player.duration() - seek) > player.position():
player.setPosition(player.position() + seek)
def play_prev(self):
self.playlist.previous()
def dragEnterEvent(self, e):
if e.mimeData().hasUrls():
e.acceptProposedAction()
def dropEvent(self, e):
for url in e.mimeData().urls():
ext = os.path.splitext(url.fileName())[-1].lower()
allowed_ext = ['.flac', '.mp3', '.mp4', '.m4a', '.mov', '.flv', 'avi', '3gp', '.mkv', '.wmv']
if ext in allowed_ext:
self.playlist.addMedia(
QMediaContent(url)
)
self.model.layoutChanged.emit()
if self.mediaPlayer.state() != QMediaPlayer.PlayingState:
i = self.playlist.mediaCount() - len(e.mimeData().urls())
self.playlist.setCurrentIndex(i)
if not self.playlist.isEmpty():
self.play_media()
def open_file(self):
filter_files = "Media (*.mp3 *.mp4 *.mkv);; Videos files (*.mp4 *.mkv);; Music Files(*.mp3)"
paths, _ = QFileDialog.getOpenFileNames(self, "Open file", "", filter_files)
if paths:
self.mediaPlayer.pause()
for path in paths:
self.playlist.addMedia(
QMediaContent(
QUrl.fromLocalFile(path)
)
)
i = self.playlist.mediaCount() - len(paths)
self.playlist.setCurrentIndex(i)
self.play_media()
self.model.layoutChanged.emit()
def update_duration(self, duration):
self.mediaPlayer.duration()
self.timeSlider.setMaximum(duration)
if duration >= 0:
self.totalTimeLabel.setText(hhmmss(duration))
def update_position(self, position):
if position >= 0:
self.currentTimeLabel.setText(hhmmss(position))
self.timeSlider.blockSignals(True)
self.timeSlider.setValue(position)
self.timeSlider.blockSignals(False)
def playlist_selection_changed(self, ix):
i = ix.indexes()[0].row()
self.playlist.setCurrentIndex(i)
self.ui_handler()
def playlist_position_changed(self, i):
if i > -1:
ix = self.model.index(i)
self.playlistView.setCurrentIndex(ix)
def set_volume(self, value):
self.mediaPlayer.setVolume(value)
def volume_changed(self, value):
self.volume_slider.setValue(value)
def keyPressEvent(self, event):
key = event.key()
modifiers = int(event.modifiers())
if (modifiers and modifiers & MOD_MASK == modifiers and
key > 0 and key != Qt.Key_Shift and key != Qt.Key_Alt and
key != Qt.Key_Control and key != Qt.Key_Meta):
key_name = QKeySequence(modifiers + key).toString()
if key_name == 'Ctrl+Right':
self.media_seek(30000)
elif key_name == 'Ctrl+Left':
self.media_seek(-30000)
elif key_name == 'Ctrl+Up':
self.mediaPlayer.setVolume(self.mediaPlayer.volume() + 5)
elif key_name == 'Ctrl+Down':
self.mediaPlayer.setVolume(self.mediaPlayer.volume() - 5)
elif key_name == 'Ctrl+O':
self.open_file()
else:
if event.key() == Qt.Key_Space:
self.play_media()
elif event.key() == Qt.Key_MediaPlay:
self.play_media()
elif event.key() == Qt.Key_MediaNext:
self.play_next()
elif event.key() == Qt.Key_MediaPrevious:
self.play_prev()
elif event.key() == Qt.Key_Escape:
self.close()
elif event.key() == Qt.Key_F:
self.fullscreen()
elif event.key() == Qt.Key_Right:
self.media_seek(5000)
elif event.key() == Qt.Key_Left:
self.media_seek(-5000)
class MainWindow(QMainWindow, Ui_MainWindow):
"""
主窗口
"""
barrier_gate = 0
lpr_thread = 0
status_bar = 0
business = 0
is_autoBarrierControl = 0
video_widgets = 0
def __init__(self, is_admin, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.setStatusBar(self.statusbar)
self.lpr_thread = LPRThread()
self.business = Util()
self.statusbar.showMessage("程序正在初始化...")
# 在模型加载完成之前这两个菜单不可用
self.actionSimulateEnter.setEnabled(False)
self.actionSimulateLeave.setEnabled(False)
self.lpr_thread.initComplete.connect(self.on_lpr_initComplete)
self.lpr_thread.identifyComplete.connect(self.on_lpr_identifyComplete)
# 只有管理员可以设置收费标准
if not is_admin:
self.actionChangeStandard.setEnabled(False)
# 显示汽车入库和出库动画的VideoWidget
self.video_widgets = QVideoWidget(self.labelGateAnimation.parent())
self.video_widgets.show()
self.video_widgets.setGeometry(self.labelGateAnimation.geometry())
# 显示汽车入库和出库动画的QMediaPlayer
self.media_player = QMediaPlayer()
self.media_player.setVideoOutput(self.video_widgets)
# 显示汽车照片的lable
#self.labelCarPhote.setStyleSheet("border: 2px solid red")
self.labelCarPhote.setScaledContents(True)
#self.labelGateAnimation.setStyleSheet("border: 2px solid red")
self.labelGateAnimation.setScaledContents(True)
# 开闸和关闸按钮根据自动设置决定是否显示
if self.actionAutoBarrierControl.isChecked():
self.pushButtonEnter.setEnabled(False)
self.pushButtonLeave.setEnabled(False)
else:
self.pushButtonEnter.setEnabled(True)
self.pushButtonLeave.setEnabled(True)
def on_lpr_initComplete(self):
"""
槽函数：车牌识别模型初始化完成
"""
self.actionSimulateEnter.setEnabled(True)
self.actionSimulateLeave.setEnabled(True)
self.statusbar.showMessage("初始化完成...")
def on_lpr_identifyComplete(self, file_path, lpn, is_enter):
"""
槽函数：车牌识别完成
@param file_path 车牌文件路径
@param lpn, license plate number 车牌号
@param is_enter 当前车辆是否是驶入车辆
"""
self.statusbar.showMessage(lpn + "已完成识别...")
self.labelLicensePlateNumber.setText(lpn)
# 车辆将要进入停车场
if is_enter:
self.labelLicensePlateNumber.setText(lpn)
self.labelMessage.setText("感谢您使用一路顺风停车场")
# 保存停车时间
self.business.car_entry(lpn)
self.pushButtonEnter.pressed.emit()
# 车辆将要离开停车场
else:
parking_history_time, history_charge = self.business.car_out(lpn)
self.labelMessage.setText("共计停放" + str(parking_history_time) +
"，共计收费" + str(history_charge) + "元")
self.pushButtonLeave.pressed.emit()
@pyqtSlot()
def on_actionSimulateEnter_triggered(self):
"""
菜单： 文件 - 模拟进入.
"""
file_dialog = QFileDialog()
if file_dialog.exec():
files = file_dialog.selectedFiles()
if len(files) == 1:
self.lpr_thread.identify(files[0], True)
pixmap = QPixmap(files[0])
self.labelCarPhote.setPixmap(pixmap)
@pyqtSlot()
def on_actionSimulateLeave_triggered(self):
"""
菜单： 文件 - 模拟离开.
"""
file_dialog = QFileDialog()
if file_dialog.exec():
files = file_dialog.selectedFiles()
if len(files) == 1:
self.lpr_thread.identify(files[0], False)
pixmap = QPixmap(files[0])
self.labelCarPhote.setPixmap(pixmap)
@pyqtSlot()
def on_actionSave_triggered(self):
"""
菜单： 文件 - 保存.
"""
# TODO: not implemented yet
raise NotImplementedError
@pyqtSlot()
def on_actionPrint_triggered(self):
"""
菜单： 文件 - 打印.
"""
# TODO: not implemented yet
raise NotImplementedError
@pyqtSlot()
def on_actionQuit_triggered(self):
"""
菜单： 文件 - 退出.
"""
sys.exit(0)
@pyqtSlot()
def on_actionChangeStandard_triggered(self):
"""
菜单： 设置 - 收费标准.
"""
dialogChangeStandard = DialogChangeStandard(self)
dialogChangeStandard.show()
dialogChangeStandard.exec()
@pyqtSlot()
def on_actionAutoBarrierControl_triggered(self):
"""
菜单： 设置 - 自动开闸.
"""
if self.actionAutoBarrierControl.isChecked():
self.pushButtonEnter.setEnabled(False)
self.pushButtonLeave.setEnabled(False)
else:
self.pushButtonEnter.setEnabled(True)
self.pushButtonLeave.setEnabled(True)
@pyqtSlot()
def on_actionQueryStatistics_triggered(self):
"""
菜单： 查询 - 查询统计.
"""
dialogQueryStatistics = DialogQueryStatistics(self)
dialogQueryStatistics.show()
dialogQueryStatistics.exec()
@pyqtSlot(QAction)
def on_menuAbout_triggered(self, action):
"""
菜单： 关于.
@param action DESCRIPTION
@type QAction
"""
# TODO: not implemented yet
raise NotImplementedError
@pyqtSlot()
def on_pushButtonEnter_pressed(self):
"""
按钮 - 开闸
"""
self.media_player.setMedia(
QMediaContent(QUrl.fromLocalFile(r"Resource\入库.avi")))
self.media_player.play()
@pyqtSlot()
def on_pushButtonLeave_pressed(self):
"""
按钮 - 关闸
"""
self.media_player.setMedia(
QMediaContent(QUrl.fromLocalFile(r"Resource\出库.avi")))
self.media_player.play()
# self.player.setVideoOutput(self.wgt_video)
# self.player.play()
self.videoFullScreen = False
self.widget.setFullScreen(0)
self.widget.setMaximumSize(self.wsize)
else:
self.wsize = self.widget.size()
self.widget.setFullScreen(1)
# self.player.pause()
# self.videoFullScreenWidget.show()
# self.player.setVideoOutput(self.videoFullScreenWidget)
# self.player.play()
self.videoFullScreen = True
# 这里进行按钮事件的编写
def test(self):
self.label_8.setText("测试按钮")
self.label_5.setText("测试按钮")
if __name__ == '__main__':
app = QApplication(sys.argv)
player = QMediaPlayer()
vw = QVideoWidget() # 定义视频显示的widget
vw.show()
player.setVideoOutput(vw) # 视频播放输出的widget，就是上面定义的
player.setMedia(QMediaContent(QFileDialog.getOpenFileUrl()[0])) # 选取视频文件
player.play() # 播放视频
# player.stop()
sys.exit(app.exec_())
class Match(QWidget, _match.Mixin):
def __init__(self):
super(Match, self).__init__()
self.setWindowTitle("Sumocup Match")
self.setWindowIcon(QIcon('./gui/res/icon_main.png'))
self.timerMain = QTimer(self)
self.timerDisplay = QTimer(self)
self.timerMain.timeout.connect(self.mainTimer_timeout)
self.timerDisplay.timeout.connect(self.refresh_LCD)
self.time = 0
self.count = False
self.ipcamservices = IpCamServices()
self.UI()
self.populate_medias()
self.defineShortcuts()
def UI(self):
layout = QHBoxLayout()
self.setLayout(layout)
self.vw = QVideoWidget()
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(True)
self.vw.setSizePolicy(sizePolicy)
vbox = QVBoxLayout()
vbox.addWidget(self.vw)
self.vw.show()
layout.addLayout(vbox)
self.MatchControls = QTabWidget()
self.Sponsors = QTabWidget()
self.tabMatch = TabMatch()
self.tabSponsors = TabSponsor()
self.MatchControls.addTab(self.tabMatch, 'Partida')
self.Sponsors.addTab(self.tabSponsors, 'Apoio')
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.MatchControls.sizePolicy().hasHeightForWidth())
self.MatchControls.setSizePolicy(sizePolicy)
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.Sponsors.sizePolicy().hasHeightForWidth())
self.Sponsors.setSizePolicy(sizePolicy)
vbox = QVBoxLayout()
vbox.addWidget(self.MatchControls)
vbox.addWidget(self.Sponsors)
layout.addLayout(vbox)
self.tabMatch.btnPlay.clicked.connect(self.btnPlay_onClick)
self.tabMatch.btnStop.clicked.connect(self.btnStop_onClick)
self.populate_teams()
self.ipcamservices.mainMP.setVideoOutput(self.vw)
class MainWidget(QWidget):
def __init__(self):
super(MainWidget, self).__init__()
self._blur = QGraphicsBlurEffect()
self._blur.setBlurRadius(0)
self.image = ImageView()
self.image.setGraphicsEffect(self._blur)
self.video = QVideoWidget()
self.label = QLabel()
self.label.setMaximumHeight(25)
self.label.setStyleSheet('color: rgb(200, 200, 200);')
font = QFont()
font.setPixelSize(20)
font.setWeight(QFont.Bold)
self.label.setFont(font)
self.setLayout(QVBoxLayout())
self.layout().addWidget(self.image)
self.layout().addWidget(self.video)
self.layout().addWidget(self.label)
self.mplayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.mplayer.setVideoOutput(self.video)
self.mplayer.error.connect(
lambda: print("Video:", self.mplayer.errorString()))
self.mplayer.mediaStatusChanged.connect(self.state_changed)
self.overlay = QLabel(self)
self.overlay.setFrameStyle(Qt.FramelessWindowHint)
self.overlay.setStyleSheet(
'background-color: rgba(0,0,0,0.7); color: rgba(200,200,200,1);')
self.overlay.setFont(font)
self.overlay.setVisible(False)
self.overlay.setWordWrap(True)
def resize(self):
self.overlay.setGeometry(0, 3 * self.height() // 4 - 50, self.width(),
100)
def resizeEvent(self, event):
super().resizeEvent(event)
self.resize()
def state_changed(self, state):
if state == QMediaPlayer.EndOfMedia:
self.mplayer.setPosition(0)
self.mplayer.play()
@property
def blur(self):
return self._blur.blurRadius()
@blur.setter
def blur(self, value):
self._blur.setBlurRadius(value)
def load(self, pic, *args, **kwargs):
if isinstance(pic, str):
still = path.splitext(pic)[1].lower()[1:] not in ('webm', 'mp4')
else:
still = pic.is_still if pic else True
if still:
self.image.load(pic, *args, **kwargs)
self.video.hide()
self.image.show()
self.mplayer.stop()
else:
url = pic if isinstance(pic, str) else pic.filename
self.mplayer.setMedia(QMediaContent(QUrl.fromLocalFile(url)))
self.mplayer.setMuted(True)
self.mplayer.play()
self.image.hide()
self.video.show()
self.overlay.setVisible(False)
def message(self, msg):
self.label.setText('<div align="center">{}</div>'.format(msg))
def flash(self, msg):
self.overlay.setText('<div align="center">{}</div>'.format(msg))
self.overlay.setVisible(True)
def halt(self):
self.mplayer.stop()
class Ui_MainWindow(object):
def __init__(self):
self.timer_thread = TimerThread()
self.timer_thread.update_signal.connect(self.update_lcd)
self.rpi = revpimodio2.RevPiModIO(autorefresh=True)
self.rpi.handlesignalend(self.cleanup_revpi)
self.rpi.io.I_1.reg_event(toggle_input, prefire=True)
self.rpi.io.I_1.reg_event(self.send_toggle_signal)
def setup_ui(self, MainWindow):
MainWindow.setObjectName("KnockOutMachine")
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.main_picture = QtWidgets.QLabel(self.centralwidget)
self.pixmap = QtGui.QPixmap("display/main_menu.png")
self.scaledPixmap = self.pixmap.scaled(900, 900, QtCore.Qt.KeepAspectRatio)
self.main_picture.setPixmap(self.scaledPixmap)
self.pictures = QtWidgets.QLabel()
self.pictures.setObjectName("pictures")
self.pictures.setAlignment(QtCore.Qt.AlignCenter)
self.pictures.setMinimumSize(500, 500)
self.pictures.hide()
self.player = QtMultimedia.QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.video_frame = QVideoWidget()
self.video_frame.resize(960, 540)
self.video_frame.hide()
palette = QtGui.QPalette()
palette.setColor(QtGui.QPalette.Text, QtCore.Qt.white)
mfont = QtGui.QFont("Times", 80, QtGui.QFont.Bold)
self.messages = QtWidgets.QLineEdit(self.centralwidget)
self.messages.setObjectName("messages")
self.messages.setAlignment(QtCore.Qt.AlignCenter)
self.messages.setPalette(palette)
self.messages.setReadOnly(True)
self.messages.setFont(mfont)
self.messages.setFixedSize(1400, 200)
self.messages.hide()
self.model = QtGui.QStandardItemModel(self.centralwidget)
tableFont = QtGui.QFont("Times", 16)
self.tableview = QtWidgets.QTableView(self.centralwidget)
self.tableview.setObjectName("tableView")
self.tableview.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
self.tableview.setMaximumWidth(500)
self.tableview.setMaximumHeight(900)
self.tableview.verticalHeader().setDefaultSectionSize(85)
self.tableview.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
self.tableview.setFont(tableFont)
self.tableview.setModel(self.model)
self.tableview.hide()
self.input_window = QtWidgets.QWidget()
self.input_window.setWindowTitle("Bitte Namen eingeben")
self.input_window.resize(300, 100)
self.input_window.move(850, 820)
# self.input_window.setWindowFlags(
# QtCore.Qt.Window | QtCore.Qt.CustomizeWindowHint | QtCore.Qt.WindowStaysOnTopHint)
self.input_window.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
self.input_layout = QtWidgets.QFormLayout()
self.input_dialogue = QtWidgets.QLineEdit(self.centralwidget)
self.input_dialogue.setMaxLength(30)
buttonFont = QtGui.QFont("Times", 16, QtGui.QFont.Bold)
self.startButton = QtWidgets.QPushButton(self.centralwidget)
self.startButton.setFixedSize(191, 71)
self.startButton.setFont(buttonFont)
self.startButton.setObjectName("startButton")
self.startButton.clicked.connect(lambda: self.on_start_button_clicked())
self.inputButton = QtWidgets.QPushButton(self.centralwidget)
self.inputButton.setObjectName("inputButton")
self.inputButton.resize(self.inputButton.sizeHint())
self.inputButton.setDisabled(True)
self.highscoreButton = QtWidgets.QPushButton(self.centralwidget)
self.highscoreButton.setFont(buttonFont)
self.highscoreButton.setObjectName("highscoreButton")
self.highscoreButton.setFixedSize(191, 71)
self.highscoreButton.clicked.connect(lambda: self.on_high_score_button_clicked())
self.cancelTimerButton = QtWidgets.QPushButton(self.centralwidget)
self.cancelTimerButton.setFont(buttonFont)
self.cancelTimerButton.setObjectName("cancelTimerButton")
self.cancelTimerButton.setFixedSize(191, 71)
self.cancelTimerButton.clicked.connect(lambda: self.exit_timer_function())
self.cancelTimerButton.hide()
self.cancelScoreButton = QtWidgets.QPushButton(self.centralwidget)
self.cancelScoreButton.setFont(buttonFont)
self.cancelScoreButton.setObjectName("cancelScoreButton")
self.cancelScoreButton.setFixedSize(191, 71)
self.cancelScoreButton.clicked.connect(lambda: self.exit_score_function())
self.cancelScoreButton.hide()
self.lcdCounter = QtWidgets.QLCDNumber(self.centralwidget)
self.lcdCounter.setEnabled(False)
self.lcdPalette = self.lcdCounter.palette()
self.lcdCounter.setFixedSize(1350, 750)
self.lcdCounter.setSmallDecimalPoint(False)
self.lcdCounter.setDigitCount(5)
self.lcdCounter.setObjectName("lcdCounter")
self.lcdCounter.display("00.00")
self.lcdCounter.hide()
self.glass_not_set_timer, self.glass_set_timer = QtCore.QTimer(), QtCore.QTimer()
self.glass_set_timer.setSingleShot(True)
self.glass_set_timer.setInterval(100)
self.glass_set_timer.timeout.connect(self.glass_set)
self.glass_not_set_timer.setSingleShot(True)
self.glass_not_set_timer.setInterval(100)
self.glass_not_set_timer.timeout.connect(self.glass_not_set)
self.vboxPictures = QtWidgets.QVBoxLayout()
self.vboxPictures.addWidget(self.main_picture, 0, QtCore.Qt.AlignCenter)
self.vboxPictures.addWidget(self.lcdCounter, 0, QtCore.Qt.AlignCenter)
self.vboxPictures.addWidget(self.messages, 0, QtCore.Qt.AlignCenter)
self.vboxPictures.addWidget(self.pictures, 1)
self.vboxPictures.addWidget(self.video_frame, 0, QtCore.Qt.AlignCenter)
self.vboxPictures.addWidget(self.tableview, 0, QtCore.Qt.AlignCenter)
self.hboxButtons = QtWidgets.QHBoxLayout()
self.hboxButtons.addWidget(self.startButton)
self.hboxButtons.addWidget(self.highscoreButton)
self.hboxButtons.addWidget(self.cancelTimerButton)
self.hboxButtons.addWidget(self.cancelScoreButton)
self.input_layout.addRow("", self.input_dialogue)
self.input_layout.addRow("", self.inputButton)
self.input_window.setLayout(self.input_layout)
self.vbox = QtWidgets.QVBoxLayout()
self.vbox.addLayout(self.vboxPictures)
self.vbox.addStretch(1)
self.vbox.addLayout(self.hboxButtons)
self.vbox.addStretch(1)
self.input_dialogue.textChanged.connect(self.enable_input_button)
self.input_dialogue.returnPressed.connect(self.inputButton.click)
self.inputButton.clicked.connect(lambda: self.update_scores(self.input_dialogue.text(), runTime))
self.inputButton.clicked.connect(lambda: self.input_window.close())
self.inputButton.clicked.connect(lambda: self.exit_timer_function())
self.centralwidget.setLayout(self.vbox)
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
locale.setlocale(locale.LC_ALL, '')
self.retranslate_ui(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslate_ui(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("KnockOutMachine", "KnockOutMachine"))
MainWindow.showFullScreen()
MainWindow.setStyleSheet("background-color: #113f0c;")
self.startButton.setText(_translate("KnockOutMachine", "Messung starten"))
self.startButton.setStyleSheet("background-color: white;")
self.inputButton.setText(_translate("KnockOutMachine", "Eingabe bestätigen"))
self.messages.setStyleSheet("border: none;")
self.highscoreButton.setText(_translate("KnockOutMachine", "Bestenliste"))
self.highscoreButton.setStyleSheet("background-color: white;")
# self.cancelButton.setText(_translate("KnockOutMachine", "Abbrechen"))
self.cancelTimerButton.setIcon(QtGui.QIcon("display/cancel_button.png"))
self.cancelTimerButton.setIconSize(QtCore.QSize(50, 50))
self.cancelTimerButton.setStyleSheet("background-color: white;")
self.cancelScoreButton.setIcon(QtGui.QIcon("display/cancel_button.png"))
self.cancelScoreButton.setIconSize(QtCore.QSize(50, 50))
self.cancelScoreButton.setStyleSheet("background-color: white;")
self.lcdCounter.setStyleSheet("background-color: #113f0c;")
self.lcdCounter.setStyleSheet("color: white;")
self.tableview.setStyleSheet("background-color: white;")
def enable_input_button(self):
if len(self.input_dialogue.text()) > 0:
self.inputButton.setDisabled(False)
else:
self.inputButton.setDisabled(True)
def on_start_button_clicked(self):
self.lcdCounter.display("00.00")
self.movie = QtGui.QMovie("")
self.lcdCounter.setEnabled(True)
self.lcdCounter.show()
self.cancelTimerButton.show()
self.startButton.hide()
self.highscoreButton.hide()
self.main_picture.hide()
self.rpi.mainloop(blocking=False)
if Input_I1:
self.glass_not_set()
else:
self.glass_set()
def on_high_score_button_clicked(self):
self.highscoreButton.hide()
self.startButton.setDisabled(True)
self.startButton.hide()
self.main_picture.hide()
self.video_frame.hide()
self.cancelScoreButton.show()
self.tableview.show()
self.model.clear()
self.model.setHorizontalHeaderLabels(['Name', 'Zeit in Sekunden'])
self.model.setHeaderData(0, QtCore.Qt.Horizontal, QtCore.Qt.AlignJustify, QtCore.Qt.TextAlignmentRole)
self.delimiter = ';'
try:
with open('timeList.csv', 'r') as timeFile:
reader = csv.reader(timeFile, delimiter=self.delimiter)
reader = [[x.replace(',', '.') for x in l] for l in reader]
highscore_list_sorted = sorted(reader, key=lambda x: float(x[1]))[:10]
for row in highscore_list_sorted:
times = [
QtGui.QStandardItem(field.replace(".", ","))
for field in row
]
self.model.appendRow(times)
self.tableview.setColumnHidden(2, True)
except FileNotFoundError:
print("Timelist File does not exist")
def glass_not_set(self):
self.glass_not_set_timer.start()
self.messages.show()
self.messages.setText("Bitte Glas vor Sensor stellen!")
if not Input_I1:
self.glass_not_set_timer.stop()
self.glass_set()
def glass_set(self):
self.glass_set_timer.start()
self.messages.show()
self.messages.setText("Glas erkannt, wenn bereit los!")
if Input_I1:
self.glass_set_timer.stop()
self.start_timer()
def start_timer(self):
self.messages.hide()
# self.pictures.setMovie(self.movie)
# self.lcdCounter.display(runTime)
self.timer_thread.start()
def update_lcd(self):
self.lcdCounter.display(runTime)
def update_scores(self, inputName, runTime):
self.datetime = QtCore.QDateTime.currentDateTime()
self.delimiter = ';'
row = [inputName, runTime.replace(".", ","), self.datetime.toString(QtCore.Qt.DefaultLocaleShortDate)]
with open('timeList.csv', 'a', newline='') as timeFile:
writer = csv.writer(timeFile, delimiter=self.delimiter)
writer.writerow(row)
self.input_dialogue.clear()
def play_sound(self, fileName, playVideo):
if playVideo:
self.file_path = "/var/lib/revpipyload/KnockOutMachine/display/" + fileName
self.video_frame.show()
self.player.setVideoOutput(self.video_frame)
self.player.setPosition(0)
else:
self.file_path = "/var/lib/revpipyload/KnockOutMachine/sounds/" + fileName
self.url = QtCore.QUrl.fromLocalFile(self.file_path)
self.content = QtMultimedia.QMediaContent(self.url)
self.player.setMedia(self.content)
self.player.play()
def show_pictures(self, runTime):
self.messages.hide()
self.lcdCounter.setFixedSize(1050, 450)
self.play_video = False
if runTime <= 200:
self.file_name = "cheering.mp3"
self.rand = randint(0, 2)
self.case = lambda x: self.rand < x
#if self.case(1):
self.pictures.show()
self.movie = QtGui.QMovie("display/Trump.gif")
#else:
#self.file_name = "endlich_normale_leute.mp4"
#self.play_video = True
self.movie.start()
self.pictures.setMovie(self.movie)
self.play_sound(self.file_name, self.play_video)
elif runTime <= 500:
self.file_name = "applause-2.mp3"
self.rand = randint(0, 6)
self.case = lambda x: self.rand < x
if self.case(1):
self.pictures.show()
self.movie = QtGui.QMovie("display/Bier.gif")
elif self.case(2):
self.pictures.show()
self.movie = QtGui.QMovie("display/2.gif")
elif self.case(3):
self.pictures.show()
self.movie = QtGui.QMovie("display/3.gif")
elif self.case(4):
self.pictures.show()
self.movie = QtGui.QMovie("display/4.gif")
elif self.case(5):
self.pictures.show()
self.movie = QtGui.QMovie("display/5.gif")
else:
self.pictures.show()
self.movie = QtGui.QMovie("display/6.gif")
self.movie.start()
self.pictures.setMovie(self.movie)
self.play_sound(self.file_name, self.play_video)
elif runTime <= 800:
self.file_name = "laughter-2.mp3"
self.rand = randint(0, 2)
self.case = lambda x: self.rand < x
if self.case(1):
self.pictures.show()
self.movie = QtGui.QMovie("display/Bier2.gif")
else:
self.pictures.show()
self.movie = QtGui.QMovie("display/1.jpeg")
self.movie.start()
self.pictures.setMovie(self.movie)
self.play_sound(self.file_name, self.play_video)
else:
self.pictures.show()
self.file_name = "laughter-2.mp3"
self.movie = QtGui.QMovie("display/dog.gif")
self.movie.start()
self.pictures.setMovie(self.movie)
self.play_sound(self.file_name, self.play_video)
# TODO toggle outputs in certain pattern
def change_output(self, highscore):
# red leds
if highscore:
self.rpi.io.O_5 = True
self.rpi.io.O_6 = True
self.rpi.io.O_7 = True
t_end = time.time() + 10
while time.time() < t_end:
self.rpi.io.O_1 = not self.rpi.io.O_1
self.rpi.io.O_2 = not self.rpi.io.O_2
self.rpi.io.O_3 = not self.rpi.io.O_3
def send_toggle_signal(self, ioname, iovalue):
self.timer_thread.toggle_signal.emit()
def exit_score_function(self):
self.tableview.hide()
self.cancelScoreButton.hide()
self.pictures.hide()
self.highscoreButton.show()
self.startButton.setEnabled(True)
self.startButton.show()
self.main_picture.show()
def exit_timer_function(self):
self.rpi.exit(full=False)
self.timer_thread.stop_timer_signal.emit()
self.glass_set_timer.stop()
self.glass_not_set_timer.stop()
self.player.stop()
self.lcdCounter.setEnabled(False)
self.lcdCounter.hide()
self.lcdCounter.setFixedSize(1350, 750)
self.tableview.hide()
self.video_frame.hide()
self.cancelTimerButton.hide()
self.messages.hide()
self.pictures.hide()
self.highscoreButton.show()
self.startButton.setEnabled(True)
self.startButton.show()
self.main_picture.show()
# TODO add cleanup if necessary
def cleanup_revpi(self):
return None
