Exemple #1
0
class MainWindow(QMainWindow, Ui_MainWindow):
    
    launchSignal = pyqtSignal()

    def __init__(self, parent = None):
    
        QMainWindow.__init__(self, parent)
        self.setupUi(self)
        self.countdown = QTimer();
        self.startTimer()
        self.countdown.timeout.connect(self.decrement)
        self.launchSignal.connect(self.launchButton.click)
        self.launchButton.clicked.connect(self.launch)
        self.rebootButton.clicked.connect(self.reboot)
        self.shutdownButton.clicked.connect(self.shutdown)
        self.tabWidget.currentChanged.connect(self.tabChange)
        self.calibrationWidget = CalibrationWidget()
        self.tabWidget.addTab(self.calibrationWidget,"Calibration")
        self.updateWidget = UpdateWidget()
        self.updateWidget.setStatusbar(self.statusbar)
        self.tabWidget.addTab(self.updateWidget,"Update")
        self.settingsWidget = SettingsWidget(self)
        self.settingsWidget.statusBar = self.statusbar
        self.tabWidget.addTab(self.settingsWidget,"Global Settings")
        self.statusbar.showMessage("Ready")
        
    def decrement(self):
        self.lcdNumber.display(self.lcdNumber.intValue() - 1)
        if self.lcdNumber.intValue() == 0:
            self.launchSignal.emit()
            self.countdown.stop()
        
    def startTimer(self):
        self.countdown.start(1000)
        self.lcdNumber.display(10)
        
    def tabChange(self,tab):
        self.countdown.stop()

        if self.tabWidget.tabText(tab) == 'Global Settings':
            self.settingsWidget.updateImage()
            self.settingsWidget.updateImage()
        
    def gameStop(self):
        self.statusbar.showMessage("Ready")
        self.startTimer()
        
    def launch(self):
        self.countdown.stop()
        self.statusbar.showMessage("Launching Simulation...")
        launcher = Launcher()
        launcher.finished.connect(self.gameStop)
        launcher.start()
        self.launcher = launcher
        
    def reboot(self):
        call(['gksudo','reboot'])
    
    def shutdown(self):
        call(['gksudo','halt'])
 def __init__(self, parent = None):
 
     QMainWindow.__init__(self, parent)
     self.setupUi(self)
     self.countdown = QTimer();
     self.startTimer()
     self.countdown.timeout.connect(self.decrement)
     self.launchSignal.connect(self.launchButton.click)
     self.launchButton.clicked.connect(self.launch)
     self.rebootButton.clicked.connect(self.reboot)
     self.shutdownButton.clicked.connect(self.shutdown)
     self.tabWidget.currentChanged.connect(self.tabChange)
     self.calibrationWidget = CalibrationWidget()
     self.tabWidget.addTab(self.calibrationWidget,"Calibration")
     self.settingsWidget = SettingsWidget(self)
     self.settingsWidget.statusBar = self.statusbar
     self.tabWidget.addTab(self.settingsWidget,"Global Settings")
     self.statusbar.showMessage("Ready")
Exemple #3
0
    def __init__(self, parent=None):
        super(Player, self).__init__(parent)

        self.setWindowTitle("SongScreen")

        self.setFocusPolicy(Qt.StrongFocus)

        self.colorDialog = None
        self.trackInfo = ""
        self.statusInfo = ""
        self.duration = 0

        self.player = QMediaPlayer()
        self.playlist = QMediaPlaylist()
        self.player.setPlaylist(self.playlist)

        self.player.durationChanged.connect(self.durationChanged)
        self.player.positionChanged.connect(self.positionChanged)
        self.player.metaDataChanged.connect(self.metaDataChanged)
        # self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
        self.player.mediaStatusChanged.connect(self.statusChanged)
        self.player.bufferStatusChanged.connect(self.bufferingProgress)
        self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
        self.player.error.connect(self.displayErrorMessage)

        # self.videoWidget = VideoWidget()
        # self.player.setVideoOutput(self.videoWidget)

        self.slider = MediaProgressWidget()  # QSlider(Qt.Horizontal)
        self.markers = []

        self.songtext_widget = SongTextWidget()
        self.songtext_widget.show()

        # self.playlistModel = PlaylistModel()
        # self.playlistModel.setPlaylist(self.playlist)
        #
        # self.playlistView = QListView()
        # self.playlistView.setModel(self.playlistModel)
        # self.playlistView.setCurrentIndex(
        #     self.playlistModel.index(self.playlist.currentIndex(), 0))
        #
        # self.playlistView.activated.connect(self.jump)

        self.slider.setRange(0, self.player.duration() / 1000)

        self.labelDuration = QLabel()
        self.slider.sliderMoved.connect(self.seek)

        # openButton = QPushButton("Open", clicked=self.open)

        controls = PlayerControlsWidget()
        controls.setState(self.player.state())
        controls.setVolume(self.player.volume())
        # controls.setMuted(controls.isMuted())

        controls.play.connect(self.player.play)
        controls.pause.connect(self.player.pause)
        controls.stop.connect(self.stop_clicked)
        # controls.stop.connect(self.videoWidget.update)
        # controls.next.connect(self.playlist.next)
        # controls.previous.connect(self.previousClicked)
        controls.changeVolume.connect(self.player.setVolume)
        # controls.changeMuting.connect(self.player.setMuted)
        # controls.changeRate.connect(self.player.setPlaybackRate)

        self.player.stateChanged.connect(controls.setState)
        self.player.stateChanged.connect(self.setState)
        self.player.volumeChanged.connect(controls.setVolume)
        # self.player.mutedChanged.connect(controls.setMuted)

        # self.fullScreenButton = QPushButton("FullScreen")
        # self.fullScreenButton.setCheckable(True)
        #
        # self.colorButton = QPushButton("Color Options...")
        # self.colorButton.setEnabled(False)
        # self.colorButton.clicked.connect(self.showColorDialog)

        displayLayout = QHBoxLayout()
        # displayLayout.addWidget(self.videoWidget, 2)
        # displayLayout.addWidget(self.songtext_widget)
        # displayLayout.addWidget(self.playlistView)

        self.song_select_widget = SongSelectWidget()
        self.song_select_widget.song_selected.connect(self.load_song)

        self.screen_select_widget = ScreenSelectWidget()
        self.screen_select_widget.screen_selected.connect(self.display_lyrics_on_screen)
        self.screen_select_widget.active_screen = QApplication.desktop().screenNumber(self.songtext_widget)

        self.settings_button = QPushButton()
        self.settings_button.setText(self.tr("Settings..."))
        self.settings_button.clicked.connect(self.show_settings)

        sidebarLayout = QVBoxLayout()
        sidebarLayout.setContentsMargins(10, 1, 0, 1);

        sidebarLayout.addWidget(self.settings_button)
        sidebarLayout.addStretch(1);
        sidebarLayout.addWidget(self.screen_select_widget)

        displayLayout.addWidget(self.song_select_widget)
        displayLayout.addLayout(sidebarLayout)

        controlLayout = QHBoxLayout()
        controlLayout.setContentsMargins(0, 0, 0, 0)
        # controlLayout.addWidget(openButton)
        # controlLayout.addStretch(1)
        controlLayout.addWidget(controls)
        controlLayout.addStretch(1)
        controlLayout.addWidget(self.labelDuration)
        # controlLayout.addWidget(self.fullScreenButton)
        # controlLayout.addWidget(self.colorButton)

        layout = QVBoxLayout()
        layout.addLayout(displayLayout)
        hLayout = QHBoxLayout()
        hLayout.addWidget(self.slider)
        # hLayout.addWidget(self.labelDuration)
        layout.addLayout(hLayout)
        layout.addLayout(controlLayout)

        self.setLayout(layout)

        if not self.player.isAvailable():
            QMessageBox.warning(self, "Service not available",
                                "The QMediaPlayer object does not have a valid service.\n"
                                "Please check the media service plugins are installed.")

            controls.setEnabled(False)
            self.playlistView.setEnabled(False)
            # openButton.setEnabled(False)
            self.colorButton.setEnabled(False)
            self.fullScreenButton.setEnabled(False)

        self.metaDataChanged()

        self._loading_audio = False
        self._finished_song = False
        self._lyrics_fading = False

        self._song_number = -1

        self.settings = {
            'font_size': 40,
            'line_increment': 2,
            'lyrics_language': '',
        }
        self._load_settings()

        self.settings_widget = SettingsWidget(self.settings, self.lyrics_path)
        self.settings_widget.font_size_changed.connect(self.songtext_widget.set_font_size)
        self.settings_widget.line_increment_changed.connect(self.songtext_widget.set_line_increment)
        self.settings_widget.language_changed.connect(self._language_changed)

        self.song_select_widget.reset(self.available_song_numbers)
Exemple #4
0
class Player(QWidget):
    audio_path = "audio"
    lyrics_path = "lyrics"
    timings_path = os.path.join("lyrics", "timing")
    settings_path = "settings.json"

    fullScreenChanged = pyqtSignal(bool)

    def __init__(self, parent=None):
        super(Player, self).__init__(parent)

        self.setWindowTitle("SongScreen")

        self.setFocusPolicy(Qt.StrongFocus)

        self.colorDialog = None
        self.trackInfo = ""
        self.statusInfo = ""
        self.duration = 0

        self.player = QMediaPlayer()
        self.playlist = QMediaPlaylist()
        self.player.setPlaylist(self.playlist)

        self.player.durationChanged.connect(self.durationChanged)
        self.player.positionChanged.connect(self.positionChanged)
        self.player.metaDataChanged.connect(self.metaDataChanged)
        # self.playlist.currentIndexChanged.connect(self.playlistPositionChanged)
        self.player.mediaStatusChanged.connect(self.statusChanged)
        self.player.bufferStatusChanged.connect(self.bufferingProgress)
        self.player.videoAvailableChanged.connect(self.videoAvailableChanged)
        self.player.error.connect(self.displayErrorMessage)

        # self.videoWidget = VideoWidget()
        # self.player.setVideoOutput(self.videoWidget)

        self.slider = MediaProgressWidget()  # QSlider(Qt.Horizontal)
        self.markers = []

        self.songtext_widget = SongTextWidget()
        self.songtext_widget.show()

        # self.playlistModel = PlaylistModel()
        # self.playlistModel.setPlaylist(self.playlist)
        #
        # self.playlistView = QListView()
        # self.playlistView.setModel(self.playlistModel)
        # self.playlistView.setCurrentIndex(
        #     self.playlistModel.index(self.playlist.currentIndex(), 0))
        #
        # self.playlistView.activated.connect(self.jump)

        self.slider.setRange(0, self.player.duration() / 1000)

        self.labelDuration = QLabel()
        self.slider.sliderMoved.connect(self.seek)

        # openButton = QPushButton("Open", clicked=self.open)

        controls = PlayerControlsWidget()
        controls.setState(self.player.state())
        controls.setVolume(self.player.volume())
        # controls.setMuted(controls.isMuted())

        controls.play.connect(self.player.play)
        controls.pause.connect(self.player.pause)
        controls.stop.connect(self.stop_clicked)
        # controls.stop.connect(self.videoWidget.update)
        # controls.next.connect(self.playlist.next)
        # controls.previous.connect(self.previousClicked)
        controls.changeVolume.connect(self.player.setVolume)
        # controls.changeMuting.connect(self.player.setMuted)
        # controls.changeRate.connect(self.player.setPlaybackRate)

        self.player.stateChanged.connect(controls.setState)
        self.player.stateChanged.connect(self.setState)
        self.player.volumeChanged.connect(controls.setVolume)
        # self.player.mutedChanged.connect(controls.setMuted)

        # self.fullScreenButton = QPushButton("FullScreen")
        # self.fullScreenButton.setCheckable(True)
        #
        # self.colorButton = QPushButton("Color Options...")
        # self.colorButton.setEnabled(False)
        # self.colorButton.clicked.connect(self.showColorDialog)

        displayLayout = QHBoxLayout()
        # displayLayout.addWidget(self.videoWidget, 2)
        # displayLayout.addWidget(self.songtext_widget)
        # displayLayout.addWidget(self.playlistView)

        self.song_select_widget = SongSelectWidget()
        self.song_select_widget.song_selected.connect(self.load_song)

        self.screen_select_widget = ScreenSelectWidget()
        self.screen_select_widget.screen_selected.connect(self.display_lyrics_on_screen)
        self.screen_select_widget.active_screen = QApplication.desktop().screenNumber(self.songtext_widget)

        self.settings_button = QPushButton()
        self.settings_button.setText(self.tr("Settings..."))
        self.settings_button.clicked.connect(self.show_settings)

        sidebarLayout = QVBoxLayout()
        sidebarLayout.setContentsMargins(10, 1, 0, 1);

        sidebarLayout.addWidget(self.settings_button)
        sidebarLayout.addStretch(1);
        sidebarLayout.addWidget(self.screen_select_widget)

        displayLayout.addWidget(self.song_select_widget)
        displayLayout.addLayout(sidebarLayout)

        controlLayout = QHBoxLayout()
        controlLayout.setContentsMargins(0, 0, 0, 0)
        # controlLayout.addWidget(openButton)
        # controlLayout.addStretch(1)
        controlLayout.addWidget(controls)
        controlLayout.addStretch(1)
        controlLayout.addWidget(self.labelDuration)
        # controlLayout.addWidget(self.fullScreenButton)
        # controlLayout.addWidget(self.colorButton)

        layout = QVBoxLayout()
        layout.addLayout(displayLayout)
        hLayout = QHBoxLayout()
        hLayout.addWidget(self.slider)
        # hLayout.addWidget(self.labelDuration)
        layout.addLayout(hLayout)
        layout.addLayout(controlLayout)

        self.setLayout(layout)

        if not self.player.isAvailable():
            QMessageBox.warning(self, "Service not available",
                                "The QMediaPlayer object does not have a valid service.\n"
                                "Please check the media service plugins are installed.")

            controls.setEnabled(False)
            self.playlistView.setEnabled(False)
            # openButton.setEnabled(False)
            self.colorButton.setEnabled(False)
            self.fullScreenButton.setEnabled(False)

        self.metaDataChanged()

        self._loading_audio = False
        self._finished_song = False
        self._lyrics_fading = False

        self._song_number = -1

        self.settings = {
            'font_size': 40,
            'line_increment': 2,
            'lyrics_language': '',
        }
        self._load_settings()

        self.settings_widget = SettingsWidget(self.settings, self.lyrics_path)
        self.settings_widget.font_size_changed.connect(self.songtext_widget.set_font_size)
        self.settings_widget.line_increment_changed.connect(self.songtext_widget.set_line_increment)
        self.settings_widget.language_changed.connect(self._language_changed)

        self.song_select_widget.reset(self.available_song_numbers)

    @property
    def lyrics_language_path(self):
        path = QStandardPaths.locate(QStandardPaths.AppDataLocation, self.lyrics_path, QStandardPaths.LocateDirectory)
        return os.path.join(path, self.settings['lyrics_language'])

    @property
    def available_song_numbers(self):
        audios = set(
            [int(os.path.splitext(filename)[0]) for filename in os.listdir(self.audio_path) if filename[0] != '.'])
        try:
            lyrics = set(
                [int(os.path.splitext(filename)[0])
                 for filename in os.listdir(self.lyrics_language_path)
                 if filename[0] != '.']
            )
        except (ValueError, FileNotFoundError):
            lyrics = set()

        return sorted(list(audios.intersection(lyrics)))

    def show_settings(self):
        self.settings_widget.hide()
        self.settings_widget.show()

    def display_lyrics_on_screen(self, screen_number):
        desktop = QApplication.desktop()

        if screen_number >= desktop.screenCount():
            screen_number = desktop.screenNumber(self)

        rect = desktop.availableGeometry(screen_number)

        for _ in range(3):
            if screen_number != desktop.screenNumber(self):
                self.songtext_widget.setWindowFlags(Qt.FramelessWindowHint)
                self.songtext_widget.hide()
                self.songtext_widget.move(rect.x(), rect.y())
                self.songtext_widget.resize(rect.width(), rect.height())
                self.songtext_widget.showFullScreen()
            else:
                self.songtext_widget.setWindowFlags(Qt.WindowTitleHint)
                self.songtext_widget.hide()
                self.songtext_widget.move(rect.x(), rect.y())
                self.songtext_widget.resize(self.songtext_widget.minimumSize())
                self.songtext_widget.show()

        self.screen_select_widget.active_screen = screen_number

        self.activateWindow()

    def load_song(self, song_number):
        if self._song_number == song_number:
            self.seek(0)
        else:
            if self._song_number > 0:
                self._save_timings()

            self._song_number = song_number
            self.slider.dirty = False
            self._load_audio()
            self._load_lyrics()

            # self.player.play()

    def _load_audio(self):
        filename = os.path.join(self.audio_path, "{:03}.mp3".format(self._song_number))
        self.playlist.clear()
        fileInfo = QFileInfo(filename)
        if fileInfo.exists():
            url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
            if fileInfo.suffix().lower() == 'm3u':
                self.playlist.load(url)
            else:
                self.playlist.addMedia(QMediaContent(url))
                self._loading_audio = True

            self.player.play()

    def _load_lyrics(self):
        with open(os.path.join(self.lyrics_language_path, "{}.json".format(self._song_number)), 'r') as f:
            song_markers = json.load(f)

            self.markers = []

            for m in song_markers['markers']:
                marker = MediaMarker(self.slider, m['name'])
                marker.text = m['text']
                marker.progress = 0.0
                self.markers.append(marker)

            self.songtext_widget.title = "{}  {}".format(self._song_number, song_markers['title'])
            self.songtext_widget.markers = self.markers
            self.songtext_widget.fade_in()

        try:
            with open(os.path.join(self.timings_path, "{}.json".format(self._song_number)), 'r') as f:
                timings = json.load(f)
                for m, t in zip(self.markers, timings):
                    m.progress = t
        except FileNotFoundError:
            pass

        self.slider.markers = self.markers

    def _language_changed(self, _):
        available_song_numbers = self.available_song_numbers
        self.song_select_widget.reset(available_song_numbers)
        if self._song_number in available_song_numbers:
            self._load_lyrics()

    # def open(self):
    #     fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Files")
    #     self.addToPlaylist(fileNames)
    #
    # def addToPlaylist(self, fileNames):
    #     for name in fileNames:
    #         fileInfo = QFileInfo(name)
    #         if fileInfo.exists():
    #             url = QUrl.fromLocalFile(fileInfo.absoluteFilePath())
    #             if fileInfo.suffix().lower() == 'm3u':
    #                 self.playlist.load(url)
    #             else:
    #                 self.playlist.addMedia(QMediaContent(url))
    #         else:
    #             url = QUrl(name)
    #             if url.isValid():
    #                 self.playlist.addMedia(QMediaContent(url))

    def durationChanged(self, duration):
        duration /= 1000

        self.duration = duration
        self.slider.setMaximum(duration)

        if self._loading_audio:
            self._loading_audio = False

            line_total = 0
            for marker in self.markers:
                line_total += marker.linecount - 1

            silence_ratio = 5.0 / self.duration
            offset = 1.8 / line_total

            linecount = 0
            for marker in self.markers:
                if marker.progress == 0.0:
                    marker.progress = offset + (1 - offset) * (1 - silence_ratio) * linecount / line_total
                linecount += marker.linecount - 1

            self.player.pause()

    @property
    def _should_fade_out(self):
        return self.player.position() / 1000 >= self.duration - 5

    def positionChanged(self, progress):
        progress /= 1000

        if not self.slider.isSliderDown():
            self.slider.setValue(progress)

        self.updateDurationInfo(progress)

        if self.duration > 0:
            # if self.player.state() == QMediaPlayer.PlayingState:
            self.songtext_widget.progress = progress / self.duration

            if self._should_fade_out:
                self._fade_out_lyrics()

    def _fade_out_lyrics(self):
        if not self._lyrics_fading:
            self._lyrics_fading = True
            self.songtext_widget.fade_out()

    def metaDataChanged(self):
        if self.player.isMetaDataAvailable():
            self.setTrackInfo("%s - %s" % (
                self.player.metaData(QMediaMetaData.AlbumArtist),
                self.player.metaData(QMediaMetaData.Title)))

    def previousClicked(self):
        # Go to the previous track if we are within the first 5 seconds of
        # playback.  Otherwise, seek to the beginning.
        if self.player.position() <= 5000:
            self.playlist.previous()
        else:
            self.player.setPosition(0)

    def jump(self, index):
        if index.isValid():
            self.playlist.setCurrentIndex(index.row())
            self.player.play()

    def seek(self, seconds):
        self.player.setPosition(seconds * 1000)

    def setState(self, status):

        if status == QMediaPlayer.StoppedState:
            self._finished_song = True

        elif status == QMediaPlayer.PlayingState:
            if self._finished_song or (self._lyrics_fading and not self._should_fade_out):
                self._finished_song = False
                self._lyrics_fading = False
                self.songtext_widget.fade_in()

    def stop_clicked(self):
        self.player.stop()
        self._fade_out_lyrics()

    def statusChanged(self, status):
        self.handleCursor(status)

        if status == QMediaPlayer.LoadingMedia:
            self.setStatusInfo("Loading...")
        elif status == QMediaPlayer.StalledMedia:
            self.setStatusInfo("Media Stalled")
        elif status == QMediaPlayer.EndOfMedia:
            QApplication.alert(self)
        elif status == QMediaPlayer.InvalidMedia:
            self.displayErrorMessage()
        else:
            self.setStatusInfo("")

    def handleCursor(self, status):
        if status in (QMediaPlayer.LoadingMedia, QMediaPlayer.BufferingMedia, QMediaPlayer.StalledMedia):
            self.setCursor(Qt.BusyCursor)
        else:
            self.unsetCursor()

    def bufferingProgress(self, progress):
        self.setStatusInfo("Buffering %d%" % progress)

    def videoAvailableChanged(self, available):
        if available:
            self.fullScreenButton.clicked.connect(
                self.videoWidget.setFullScreen)
            self.videoWidget.fullScreenChanged.connect(
                self.fullScreenButton.setChecked)

            if self.fullScreenButton.isChecked():
                self.videoWidget.setFullScreen(True)
        else:
            self.fullScreenButton.clicked.disconnect(
                self.videoWidget.setFullScreen)
            self.videoWidget.fullScreenChanged.disconnect(
                self.fullScreenButton.setChecked)

            self.videoWidget.setFullScreen(False)

        self.colorButton.setEnabled(available)

    def setTrackInfo(self, info):
        self.trackInfo = info

        # if self.statusInfo != "":
        #     self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
        # else:
        #     self.setWindowTitle(self.trackInfo)

    def setStatusInfo(self, info):
        self.statusInfo = info

        # if self.statusInfo != "":
        #     self.setWindowTitle("%s | %s" % (self.trackInfo, self.statusInfo))
        # else:
        #     self.setWindowTitle(self.trackInfo)

    def displayErrorMessage(self):
        self.setStatusInfo(self.player.errorString())

    def updateDurationInfo(self, currentInfo):
        duration = self.duration
        if currentInfo or duration:
            currentTime = QTime((currentInfo / 3600) % 60, (currentInfo / 60) % 60,
                                currentInfo % 60, (currentInfo * 1000) % 1000)
            totalTime = QTime((duration / 3600) % 60, (duration / 60) % 60,
                              duration % 60, (duration * 1000) % 1000);

            format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
            tStr = currentTime.toString(format) + " / " + totalTime.toString(format)
        else:
            tStr = ""

        self.labelDuration.setText(tStr)

    def showColorDialog(self):
        if self.colorDialog is None:
            brightnessSlider = QSlider(Qt.Horizontal)
            brightnessSlider.setRange(-100, 100)
            brightnessSlider.setValue(self.videoWidget.brightness())
            brightnessSlider.sliderMoved.connect(
                self.videoWidget.setBrightness)
            self.videoWidget.brightnessChanged.connect(
                brightnessSlider.setValue)

            contrastSlider = QSlider(Qt.Horizontal)
            contrastSlider.setRange(-100, 100)
            contrastSlider.setValue(self.videoWidget.contrast())
            contrastSlider.sliderMoved.connect(self.videoWidget.setContrast)
            self.videoWidget.contrastChanged.connect(contrastSlider.setValue)

            hueSlider = QSlider(Qt.Horizontal)
            hueSlider.setRange(-100, 100)
            hueSlider.setValue(self.videoWidget.hue())
            hueSlider.sliderMoved.connect(self.videoWidget.setHue)
            self.videoWidget.hueChanged.connect(hueSlider.setValue)

            saturationSlider = QSlider(Qt.Horizontal)
            saturationSlider.setRange(-100, 100)
            saturationSlider.setValue(self.videoWidget.saturation())
            saturationSlider.sliderMoved.connect(
                self.videoWidget.setSaturation)
            self.videoWidget.saturationChanged.connect(
                saturationSlider.setValue)

            layout = QFormLayout()
            layout.addRow("Brightness", brightnessSlider)
            layout.addRow("Contrast", contrastSlider)
            layout.addRow("Hue", hueSlider)
            layout.addRow("Saturation", saturationSlider)

            button = QPushButton("Close")
            layout.addRow(button)

            self.colorDialog = QDialog(self)
            self.colorDialog.setWindowTitle("Color Options")
            self.colorDialog.setLayout(layout)

            button.clicked.connect(self.colorDialog.close)

        self.colorDialog.show()

    def closeEvent(self, close_event):
        self._save_timings()
        self._save_settings()
        self.songtext_widget.close()
        self.settings_widget.close()

    def keyPressEvent(self, key_event):
        if key_event.key() == Qt.Key_Space:
            key_event.accept()
            if self.player.state() == QMediaPlayer.PlayingState:
                self.player.pause()
            elif self.player.state() in [QMediaPlayer.PausedState, QMediaPlayer.StoppedState]:
                self.player.play()
        elif key_event.key() == Qt.Key_M:
            key_event.accept()
            self.slider.set_closest_marker_to_current_progress()

    def _save_timings(self):
        if self.slider.dirty:
            with open(os.path.join(self.timings_path, "{}.json".format(self._song_number)), 'w') as f:
                json.dump([marker.progress for marker in self.markers], f, indent=2)

    def _save_settings(self):
        # TODO : refactor and use QSettings directly

        # with open(self.settings_path, 'w') as f:
        self.settings.update({
            'lyrics_screen': QApplication.desktop().screenNumber(self.songtext_widget),
            'control_window_position': self.pos(),
        })

        # json.dump(self.settings, f, indent=2)

        settings = QSettings("Maccesch", "SongScreen")

        for key, value in self.settings.items():
            settings.setValue(key, value)

    def _load_settings(self):
        # try:
        #     with open(self.settings_path, 'r') as f:
        #         settings = json.load(f)
        settings = QSettings("Maccesch", "SongScreen")

        if settings.contains('lyrics_screen'):
            self.display_lyrics_on_screen(settings.value('lyrics_screen'))

        if settings.contains('control_window_position'):
            self.move(settings.value('control_window_position'))

        for key in settings.allKeys():
            self.settings[key] = settings.value(key)

        # self.settings.update(settings)

        self.songtext_widget.set_font_size(self.settings['font_size'])
        self.songtext_widget.set_line_increment(self.settings['line_increment'])

        # except (FileNotFoundError, ValueError):
        #     pass

        if not os.path.exists(self.lyrics_language_path) or not self.settings['lyrics_language']:
            languages = list(
                filter(lambda p: os.path.isdir(os.path.join(self.lyrics_path, p)) and p != "timings",
                       os.listdir(self.lyrics_path))
            )
            self.settings['lyrics_language'] = languages[0] if languages else ""
Exemple #5
0
    def initUI(self):
        '''
        Setting up Interface
        '''
        mainWidget = QtGui.QSplitter(QtCore.Qt.Horizontal)
        
        self.fileMenu=FileSourceWidget(self)

        mainWidget.addWidget(self.fileMenu)
        tabsAndSettingsWidget=QtGui.QWidget(self)
        tabsAndSettingsLayout=QtGui.QHBoxLayout(tabsAndSettingsWidget)
        
        tabs = QtGui.QTabWidget(self)
        
        #### NOT THE BEST WAY TO IMPLEMENT THAT!
        self.lastCalcMultiple=False
        
    
        images=QtGui.QWidget(self)
        highlightColot = str('white')#tabs.palette().color(QtGui.QPalette.HighlightedText).name())
        imagesLayout=QtGui.QVBoxLayout(images)
        tabs.addTab(images,"Results")
        
        self.figure = plt.figure(facecolor=highlightColot)
        self.canvas = FigureCanvas(self.figure)
        self.toolbar = NavigationToolbar(self.canvas, self)
        imagesLayout.addWidget(self.canvas)
        imagesLayout.addWidget(self.toolbar)
        
       
        fastFRET=QtGui.QWidget(self)
        fastFRETLayout=QtGui.QVBoxLayout(fastFRET)
        tabs.addTab(fastFRET,"Raw signal")
        self.figure1 = plt.figure(facecolor=highlightColot)
        self.canvas1 = FigureCanvas(self.figure1)
        self.toolbar1 = NavigationToolbar(self.canvas1, self)
        fastFRETLayout.addWidget(self.canvas1)
        fastFRETLayout.addWidget(self.toolbar1)
        
        results=QtGui.QWidget(self)
        resultsLayout=QtGui.QVBoxLayout(results)
        tabs.addTab(results,"Export")
        self.tableWidget=TableWidget(self)
        resultsLayout.addWidget(self.tableWidget)
        
        self.logText = QtGui.QTextEdit()
        self.logText.setMaximumHeight(130)
        self.logText.setReadOnly(True)
        self.logText.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
        self.logText.append("Welcome to Fretty 1.1! ")
        self.logger = Logger(self.logText)
        #self.errors = Logger(self.logText)
        sys.stdout = self.logger        
        
        tabs_and_logger_widget=QtGui.QWidget(self)
        tabs_and_logger_layout=QtGui.QVBoxLayout(tabs_and_logger_widget)
        tabs_and_logger_layout.addWidget(tabs)
        tabs_and_logger_layout.addWidget(self.logText)
        

        
        tabsAndSettingsLayout.addWidget(tabs_and_logger_widget)
        
        
        
        
        
        
        
        
        self.settingsWidget=SettingsWidget(self)
        self.settings=self.settingsWidget.collectSettings()
        
        tabsAndSettingsLayout.addWidget(self.settingsWidget)
        mainWidget.addWidget(tabsAndSettingsWidget)
        self.setCentralWidget(mainWidget)
        self.setWindowTitle('FRETTY')   
        
        
        self.assignConnections()
Exemple #6
0
class MainWindow(QtGui.QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.initUI()
        self.show()
    
    def initUI(self):
        '''
        Setting up Interface
        '''
        mainWidget = QtGui.QSplitter(QtCore.Qt.Horizontal)
        
        self.fileMenu=FileSourceWidget(self)

        mainWidget.addWidget(self.fileMenu)
        tabsAndSettingsWidget=QtGui.QWidget(self)
        tabsAndSettingsLayout=QtGui.QHBoxLayout(tabsAndSettingsWidget)
        
        tabs = QtGui.QTabWidget(self)
        
        #### NOT THE BEST WAY TO IMPLEMENT THAT!
        self.lastCalcMultiple=False
        
    
        images=QtGui.QWidget(self)
        highlightColot = str('white')#tabs.palette().color(QtGui.QPalette.HighlightedText).name())
        imagesLayout=QtGui.QVBoxLayout(images)
        tabs.addTab(images,"Results")
        
        self.figure = plt.figure(facecolor=highlightColot)
        self.canvas = FigureCanvas(self.figure)
        self.toolbar = NavigationToolbar(self.canvas, self)
        imagesLayout.addWidget(self.canvas)
        imagesLayout.addWidget(self.toolbar)
        
       
        fastFRET=QtGui.QWidget(self)
        fastFRETLayout=QtGui.QVBoxLayout(fastFRET)
        tabs.addTab(fastFRET,"Raw signal")
        self.figure1 = plt.figure(facecolor=highlightColot)
        self.canvas1 = FigureCanvas(self.figure1)
        self.toolbar1 = NavigationToolbar(self.canvas1, self)
        fastFRETLayout.addWidget(self.canvas1)
        fastFRETLayout.addWidget(self.toolbar1)
        
        results=QtGui.QWidget(self)
        resultsLayout=QtGui.QVBoxLayout(results)
        tabs.addTab(results,"Export")
        self.tableWidget=TableWidget(self)
        resultsLayout.addWidget(self.tableWidget)
        
        self.logText = QtGui.QTextEdit()
        self.logText.setMaximumHeight(130)
        self.logText.setReadOnly(True)
        self.logText.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
        self.logText.append("Welcome to Fretty 1.1! ")
        self.logger = Logger(self.logText)
        #self.errors = Logger(self.logText)
        sys.stdout = self.logger        
        
        tabs_and_logger_widget=QtGui.QWidget(self)
        tabs_and_logger_layout=QtGui.QVBoxLayout(tabs_and_logger_widget)
        tabs_and_logger_layout.addWidget(tabs)
        tabs_and_logger_layout.addWidget(self.logText)
        

        
        tabsAndSettingsLayout.addWidget(tabs_and_logger_widget)
        
        
        
        
        
        
        
        
        self.settingsWidget=SettingsWidget(self)
        self.settings=self.settingsWidget.collectSettings()
        
        tabsAndSettingsLayout.addWidget(self.settingsWidget)
        mainWidget.addWidget(tabsAndSettingsWidget)
        self.setCentralWidget(mainWidget)
        self.setWindowTitle('FRETTY')   
        
        
        self.assignConnections()
        
        
    def assignConnections(self):
        '''
        Assigning connections
        '''
        self.connect(self.fileMenu,QtCore.SIGNAL("updateFilePreview"),self.set_data)
        self.connect(self.fileMenu,QtCore.SIGNAL("updateUI"),self.repaint)
        self.connect(self.fileMenu,QtCore.SIGNAL("runCalculations"),self.plot_multiple_files)
        self.connect(self.settingsWidget,QtCore.SIGNAL("settingsUpdatedSignal"),self.apply_settings)
        
        
    def apply_settings(self,settings):
        self.settings=settings
        if self.lastCalcMultiple:
            try:
                self.plot_multiple_files()
            except IndexError:
                print "<font color=#FF0000>No files loaded.</font>"
        else:
            try:
                self.plot_single_file(self.calculate_single_file(self.data,self.settings,self.name))
            except AttributeError:
                try:
                    self.plot_multiple_files()
                except IndexError:
                    print "<font color=#FF0000>No files loaded.</font>"
    
    def set_data(self,data,name):
        self.data=data
        self.name=name
        self.plot_single_file(self.calculate_single_file(self.data,self.settings,self.name))
        self.lastCalcMultiple=False
        

       
    def plot_raw(self,data,settings,showplots=True):
        time=data.time
        cy3=data.donor
        cy5=data.acceptor
        timestep=data.timestep
        
        cy3_int=np.round(timestep*cy3*1000)
        cy5_int=np.round(timestep*cy5*1000)
        max=[cy3_int.max() if cy5_int.max()<=cy3_int.max() else cy5_int.max()][0]
        av_max=[np.average(cy3_int) if np.average(cy5_int)<=np.average(cy3_int) else np.average(cy5_int)][0]
        max=np.round(max/3)
        x=np.arange(0,max,1)
        cy3_hist=np.histogram(cy3_int,x,normed=True)[0]
        cy5_hist=np.histogram(cy5_int,x,normed=True)[0]
        x_axis=x[:-1]
        rawframe=np.vstack((x_axis,cy3_hist,cy5_hist)).T
        np.savetxt('data.txt',rawframe,header="#MHz Cy3 Cy5",fmt='%.3f',)
        m, sd1, = [5, 1]
        p = [m, sd1] # Initial guesses for leastsq
        
        plsq_cy3 = leastsq(res, p, args = (cy3_hist, x_axis))
        plsq_cy5 = leastsq(res, p, args = (cy5_hist, x_axis))

        cy3_est = norm(x_axis, plsq_cy3[0][0], plsq_cy3[0][1])
        cy5_est = norm(x_axis, plsq_cy5[0][0], plsq_cy5[0][1])

        x_axis=x_axis/(timestep*1000)
        cy3_guess=plsq_cy3[0]/(timestep*1000)
        cy5_guess=plsq_cy5[0]/(timestep*1000)
        if settings['backgrMetod']=='Auto (gauss)':
            cy3_bgrnd=cy3_guess[0]
            cy5_bgrnd=cy5_guess[0]
        elif settings['backgrMetod']=='Manual':
            cy3_bgrnd=settings['BD']
            cy5_bgrnd=settings['BA']
            
        if settings['threshMethod']=='Auto (gauss)':
            if settings['threshLogic']=='SUM':
                cy3_thld=(cy3_guess[1]+cy5_guess[1])*settings['CD']
                cy5_thld=(cy3_guess[1]+cy5_guess[1])*settings['CD']
            else:
                cy3_thld=cy3_guess[1]*settings['CD']
                cy5_thld=cy5_guess[1]*settings['CA']
                
        elif settings['threshMethod']=='Manual thresholds':
            cy3_thld=settings['TD']
            cy5_thld=settings['TA']
        elif settings['threshMethod']=='Select top events':
            cy3_thld=cy3[np.argpartition(cy3,-settings['ND'])[-settings['ND']:]].min()-cy3_bgrnd
            cy5_thld=cy5[np.argpartition(cy5,-settings['NA'])[-settings['NA']:]].min()-cy5_bgrnd
        
        #ms, cs , ws = fit_mixture(cy3.reshape(cy3.size,1),1)
        #gaus2=ws[0]*mlab.normpdf(x_axis,ms[0],cs[0])
        
        self.figure1.clf()
        if showplots:
            gs = gridspec.GridSpec(2, 2)
            ax00 = self.figure1.add_subplot(gs[0,0])
            ax00.plot(x_axis, cy3_hist,color='blue', label='Signal')
            #ax00.hist(cy3,np.arange(0,max,1/(timestep*1000)), label='Raw',normed=True)
            ax00.plot(x_axis, cy3_est,color='black', label='Fitted')
            ax00.axvline(cy3_bgrnd,color='red', label='Bkgnd',linewidth=3)
            ax00.axvline(cy3_bgrnd+cy3_thld,color='green', label='Thld',linewidth=3)
            #ax00.plot(x_axis,gaus2, linewidth=3)
            ax00.legend()   
            ax00.set_title('Donor signal spectra')
            ax00.set_ylabel('Amount,%')
            ax00.set_xlabel('Count, kHz')
            scale=[cy3_thld+1 if 10*cy3_guess[1]<=cy3_thld else 10*cy3_guess[1]][0]
            ax00.set_xlim(0,np.round(cy3_guess[0]+scale))

            
            ax01 = self.figure1.add_subplot(gs[0,1])
            ax01.plot(x_axis, cy5_hist,color='blue', label='Raw')
            ax01.plot(x_axis, cy5_est,color='black', label='Fitted')
            ax01.axvline(cy5_bgrnd,color='red', label='Bkgnd',linewidth=3)
            ax01.axvline(cy5_bgrnd+cy5_thld,color='green', label='Thld',linewidth=3)
            ax01.legend() 
            ax01.set_title('Acceptor signal spectra')
            ax01.set_ylabel('Amount,%')
            ax01.set_xlabel('Count, kHz')
            scale=[cy5_thld+1 if 10*cy5_guess[1]<=cy5_thld else 10*cy5_guess[1]][0]
            ax01.set_xlim(0,np.round(cy5_guess[0]+scale))
                    
            ax10 = self.figure1.add_subplot(gs[1,0])
            ax10.plot(time,cy3,color='blue',linewidth=0.02,label='Signal')
            ax10.axhline(cy3_bgrnd,color='red', label='Bkgnd',linewidth=2)
            ax10.axhline(cy3_bgrnd+cy3_thld,color='green', label='Thld',linewidth=2)
            ax10.axhline(settings['UTD']-cy3_bgrnd,color='black', label='Up Thld',linewidth=2)
            ax10.legend()   
            ax10.set_title('Donor signal')
            ax10.set_ylabel('Count, kHz')
            ax10.set_xlabel('Time, S')
            
            ax11 = self.figure1.add_subplot(gs[1,1])
            ax11.plot(time,cy5,color='blue',linewidth=0.02,label='Signal')
            ax11.axhline(cy5_bgrnd,color='red', label='Bkgnd',linewidth=2)
            ax11.axhline(cy5_bgrnd+cy5_thld,color='green', label='Thld',linewidth=2)
            ax11.axhline(settings['UTA']-cy5_bgrnd,color='black', label='Up Thld',linewidth=2)
            ax11.legend()     
            ax11.set_title('Acceptor signal')
            ax11.set_ylabel('Count, kHz')
            ax11.set_xlabel('Time, S')
            self.figure1.tight_layout()
            self.canvas1.draw()
        
        return cy3_bgrnd,cy3_thld,cy5_bgrnd,cy5_thld


    def plot_single_file(self,(result,settings,name,E)):
        self.figure.clf()
        ax = self.figure.add_subplot(111)
#        result=np.histogram(fret.proximity_ratio(gamma=gamma),np.arange(0,1.05,0.05),normed=True)
        axis=result[1][:-1]+(result[1][1]-result[1][0])/2.0
        ax.plot(axis,result[0],linewidth=3, label='Eff')

        if (settings['nGausFit']!=0):
            ms, cs , ws = fit_mixture(E.reshape(E.size,1),settings['nGausFit'])
            
            gaus=np.zeros((settings['nGausFit'],axis.size))
            for i in range(settings['nGausFit']):
                gaus[i]=ws[i]*mlab.normpdf(axis,ms[i],cs[i])
                ax.plot(axis,gaus[i], linewidth=2,
                    label='Fit ' + str(i) +', Pos '+str(np.round(ms[i],2))+', '+str(np.round(ws[i]*100,2))+'%')
            ax.plot(axis,gaus.sum(0), linewidth=2,linestyle='--')

        ax.set_title(os.path.basename(name))
        ax.set_ylabel('Amount, %')
        ax.set_xlabel('FRET Eff')
        box = ax.get_position()
        ax.set_position([box.x0, box.y0 + box.height * 0.1,
                 box.width, box.height * 0.9])
        #ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.1),ncol=5)
        if (settings['nGausFit']==0):
            table=np.vstack((axis,np.round(result[0],4))).transpose()
            self.tableWidget.buildFromList(np.vstack((['FRET eff.','Amount'],table)),False)
        else:
            table=np.vstack((axis,np.round(result[0],4),gaus,gaus.sum(0))).transpose()
            header= ['FRET eff.','Amount']
            [header.append('Fitted ' + str(i)) for i in range(1,settings['nGausFit']+1)]
            header.append('Fitted Sum')
            self.tableWidget.buildFromList(np.vstack((header,table)),False)
            self.tableWidget.addFromList(np.array([[' ']]))
            gausses= np.array([np.array(ms),np.array(cs).flatten(),np.array(ws)]).T
            gausses[:,2]*=100
            gausses=np.hstack(( np.transpose([np.arange(1,gausses.shape[0]+1)]),gausses ))

            self.tableWidget.addFromList(np.vstack( ([['#','Position','Sigma','Area, %']],gausses) ).T)
            

        self.tableWidget.addFromList(np.array([[' ']]))   
        self.tableWidget.addFromList(np.hstack(([['Settings'],['']],np.array([settings.keys(),[str(qstring) for qstring in settings.values()]]))))
        #print np.array([settings.keys(),[str(qstring) for qstring in settings.values()]])
        self.canvas.draw()