add settings menu

arch · arch · commit 78f0cedb299c · 2021-07-25T12:06:22.000+02:00
diff --git a/README.md b/README.md
@@ -4,7 +4,7 @@ A small Python program that use use Computer Vision to partially automate the ge
 
 ## Getting Started
 
-The application has an build in UI. Due to the limitations (mainly on Windows) it is not intended for productive use. Therefore i create a lua script to integrate the tool in [Open Funscripter (OFS)](https://github.com/OpenFunscripter/OFS). For the Installation see my detailed step by step [OFS Integration instruction](https://github.com/michael-mueller-git/Python-Funscript-Editor/blob/main/docs/app/docs/user-guide/ofs-integration.md). By default the application is configured for 3D Side-By-Side VR Videos. If you want to track 2D Videos you have to manually change the config! Therefore read the [configuration page](https://github.com/michael-mueller-git/Python-Funscript-Editor/blob/main/docs/app/docs/user-guide/config.md) in the application documentation.
+The application has an build in UI. Due to the limitations (mainly on Windows) it is not intended for productive use. Therefore i create a lua script to integrate the tool in [Open Funscripter (OFS)](https://github.com/OpenFunscripter/OFS). For the Installation see my detailed step by step [OFS Integration instruction](https://github.com/michael-mueller-git/Python-Funscript-Editor/blob/main/docs/app/docs/user-guide/ofs-integration.md). Advanced user should read the [configuration page](https://github.com/michael-mueller-git/Python-Funscript-Editor/blob/main/docs/app/docs/user-guide/config.md) in the application documentation.
 
 ## Documentation
 
diff --git a/docs/app/build.sh b/docs/app/build.sh
@@ -5,6 +5,8 @@ if [ -z "$(pip3 list | grep "mkdocs")" ] ; then
     pip3 install mkdocs
 fi
 
+rm -rf ./site
+
 if command -v mkdocs ; then
     mkdocs build
 else
diff --git a/docs/app/docs/user-guide/algorithms.md b/docs/app/docs/user-guide/algorithms.md
@@ -4,8 +4,6 @@
 
 Idea: By using [OpenCV Tracker](https://learnopencv.com/object-tracking-using-opencv-cpp-python/), we can determine the relative movements in a static camera setup and map them into Funscript actions using simple signal processing.
 
-The Algorithm is implemented for 3D Side-By-Side VR Videos. Some parameter are currently hard coded. It should be possible to expand the functionality to 2D Videos by changing the code, with the following limitations.
-
 ### Limitations
 
 - Static camera setup
diff --git a/docs/app/docs/user-guide/config.md b/docs/app/docs/user-guide/config.md
@@ -22,10 +22,8 @@ Config Files:
 - `use_kalman_filter`: (bool) Enable Kalman Filter
 - `use_zoom` (bool): Enable or disable an additional step to zoom in the Video before selecting a tracking feature for the Woman or Men.
 - `zoom_factor:` (float): Set the desired zoom value which will be used when the zoom function is activated.
-- `tracking_direction` (str): Specify the tracking direction. Allowed values are `'x'` and `'y'`.
 - `max_playback_fps` (int): Limit the max player speed in the tracking preview window (0 = disable limit)
 - `preview_scaling` (float): Set the preview image scaling factor. With a value of `1.0`, the window should fill the height or width of the screen depending on the aspect ratio of the video.
-- `projection`: (str): Set the video type. All available options can be obtained from the `projection.yaml` file. Each root keys represent an option. Available Options: `'flat'` = 2D Videos, `'vr_he_sbs'` = 3D VR Side-By-Side Video
 - `tracker`: (str) Specify the tracker algorithm. Available options are `'MIL'`, `'KCF'`, `'CSRT'`.
 
 #### `hyperparameter.yaml`
diff --git a/docs/app/docs/user-guide/images/ofs_integration_09.jpg b/docs/app/docs/user-guide/images/ofs_integration_09.jpg
diff --git a/docs/app/docs/user-guide/ofs-integration.md b/docs/app/docs/user-guide/ofs-integration.md
@@ -23,9 +23,7 @@ We use a lua script to communicate between the Python Funscript Generator and th
    <br> ![Enable OFS Integration](./images/ofs_integration_07.jpg)
 8. Navigate to `Options : Keys : Dynamic` and insert a shortcut for the funscript generator.
    <br> ![Assign an Shortcut](./images/ofs_integration_08.jpg)
-9. By default the application assume you want to track VR 3D Side-By-Side Videos. If you want to track 2D Videos, you have to change the settings in a configuration file. The config file is located in `funscript-editor/funscript_editor/config/settings.yaml`. Open the file with an text editor and change the line `projection: 'vr_he_sbs'` to `projection: 'flat'`. Then save the file.
-   <br> ![Settings to Track 2D Videos](./images/ofs_integration_09.jpg)
-10. Now you can use the shortcut at any position in the video to start the funscript generator.
+9. Now you can use the shortcut at any position in the video to start the funscript generator.
 
 ## Troubleshot
 
diff --git a/funscript_editor/algorithms/funscriptgenerator.py b/funscript_editor/algorithms/funscriptgenerator.py
@@ -32,19 +32,20 @@
 @dataclass
 class FunscriptGeneratorParameter:
     """ Funscript Generator Parameter Dataclass with default values """
+    # No default values
     video_path: str # no default value
+    track_men: bool
+    direction: str
+    projection: str
+
+    # Settings
     start_frame: int = 0 # default is video start (input: set current video position)
     end_frame: int = -1 # default is video end (-1)
-    track_men: bool = True # set by userinput at start (message box)
     raw_output: bool = False
-
-    # Settings
     max_playback_fps: int = max((0, int(SETTINGS['max_playback_fps'])))
-    direction: str = SETTINGS['tracking_direction']
     use_zoom: bool = SETTINGS['use_zoom']
     zoom_factor: float = max((1.0, float(SETTINGS['zoom_factor'])))
     preview_scaling: float = float(SETTINGS['preview_scaling'])
-    projection: str = str(SETTINGS['projection']).lower()
     use_kalman_filter: bool = SETTINGS['use_kalman_filter']
 
     # General
diff --git a/funscript_editor/api.py b/funscript_editor/api.py
@@ -41,5 +41,4 @@ def generate_funscript(
             str(video_file), str(start_time), str(end_time), str(output_file))
     app = QtWidgets.QApplication(sys.argv)
     generator = FunscriptGeneratorWindow(video_file, start_time, end_time, output_file)
-    generator.run()
     sys.exit(app.exec_())
diff --git a/funscript_editor/config/projection.yaml b/funscript_editor/config/projection.yaml
@@ -2,17 +2,17 @@
 # Do not change any parameters here unless you know exactly what you are doing!
 # For VR video filer options see: https://ffmpeg.org/ffmpeg-filters.html#v360
 
-# 3D Side-By-Side 180 Dome VR Videos
 vr_he_sbs:
+  name: '3D VR Video'
   video_filter: 'v360=input=he:in_stereo=sbs:pitch=${phi}:output=flat:d_fov=${fov}:w=${width}:h=${height}'
   parameter:
     height: 720
     width: 1240
     fov: 100
     phi: -45
 
-# 2D Videos
 flat:
+  name: '2D Video'
   video_filter: 'scale=${width}:${height}'
   parameter:
     height: 720
diff --git a/funscript_editor/config/settings.yaml b/funscript_editor/config/settings.yaml
@@ -10,20 +10,12 @@ use_zoom: False
 # Set the desired zoom value which will be used when the zoom function is activated.
 zoom_factor: 4.0
 
-# Specify the tracking direction. Allowed values are `'x'` and `'y'`.
-tracking_direction: 'y'
-
 # Limit the max player speed in the tracking preview window (0 = disable limit)
 max_playback_fps: 0
 
 # Set the preview image scaling factor. With a value of 1.0, the window should fill the height
 # or width of the screen depending on the aspect ratio of the video.
 preview_scaling: 0.6
 
-# Set the video type. Available Options:
-# - 'flat': 2D Videos
-# - 'vr_he_sbs': 3D VR Side-By-Side Video
-projection: 'flat'
-
 # Specify the tracker algorithm. Available options are 'MIL', 'KCF', 'CSRT'.
 tracker: 'CSRT'
diff --git a/funscript_editor/ui/build_ui.sh b/funscript_editor/ui/build_ui.sh
@@ -1,3 +1,4 @@
 #!/bin/sh
 
 pyuic5 funscript_editor_view.ui -o funscript_editor_view.py
+pyuic5 settings_view.ui -o settings_view.py
diff --git a/funscript_editor/ui/funscript_editor_window.py b/funscript_editor/ui/funscript_editor_window.py
@@ -287,9 +287,9 @@ def __open_video(self):
 
         self.video_player.set_funscript(self.funscript)
         self.funscript_visualizer.set_funscript(self.funscript)
-        self.ui.seekBar.setMaximum(max((0, self.video_player.get_length-1)))
+        self.ui.seekBar.setMaximum(max((0, self.video_player.get_length-2)))
         self.ui.seekBar.setValue(0)
-        self.ui.timestamp.setText('0 ')
+        self.ui.timestamp.setText(FFmpegStream.millisec_to_timestamp(0)+' ')
 
     def __new_funscript(self):
         self.funscript = Funscript(fps=self.video_player.get_fps)
@@ -300,13 +300,10 @@ def __generate_funscript(self):
         if self.funscript is None: return
         if self.video_player is None: return
         if self.video_player.get_video_file is None: return
+        # self.video_player.set_indicate_bussy(True) # we have no event if the user abort, for now we disable the bussy indicator
         start_time = self.video_player.get_current_timestamp_in_millis
         next_action = self.funscript.get_next_action(self.video_player.get_current_timestamp_in_millis+100)
-        if next_action['at'] > self.video_player.get_current_timestamp_in_millis+100:
-            end_time = next_action['at']
-        else:
-            end_time = -1
-
+        end_time = next_action['at'] if next_action['at'] > self.video_player.get_current_timestamp_in_millis+100 else -1.0
         self.__logger.info("Stop at {}".format(end_time))
 
         self.funscript_generator_window = FunscriptGeneratorWindow(
@@ -316,7 +313,6 @@ def __generate_funscript(self):
                 self.funscript
             )
         self.funscript_generator_window.funscriptCompleted.connect(self.__funscript_generated)
-        self.funscript_generator_window.run()
 
 
     def __funscript_generated(self, funscript, status, success):
diff --git a/funscript_editor/ui/funscript_generator_window.py b/funscript_editor/ui/funscript_generator_window.py
@@ -6,6 +6,7 @@
 from funscript_editor.utils.logging import setup_logging
 from funscript_editor.algorithms.funscriptgenerator import FunscriptGeneratorThread, FunscriptGeneratorParameter
 from funscript_editor.data.funscript import Funscript
+from funscript_editor.ui.settings_dialog import SettingsDialog
 
 from PyQt5 import QtCore, QtGui, QtWidgets
 
@@ -53,35 +54,19 @@ def __init__(self,
         fps = cap.get(cv2.CAP_PROP_FPS)
         cap.release()
 
+        self.video_file = video_file
         self.funscript = Funscript(fps)
         self.output_file = output_file
 
-        if False:
-            reply = QtWidgets.QMessageBox.question(None, 'Generate Funscript ', \
-                    'Do you want to generate the funscript actions by tracking features in the Video? ',
-                    QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No, QtWidgets.QMessageBox.No)
-            if reply != QtWidgets.QMessageBox.Yes:
-                logging.info('Abort Funscript Generator')
-                sys.exit()
-
-        reply = QtWidgets.QMessageBox.question(None, 'Track Men', 'Do you want to track the Men? ',
-                QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No, QtWidgets.QMessageBox.No)
-        trackMen = True if reply == QtWidgets.QMessageBox.Yes else False
+        self.start_frame = int(round(float(start_time)/(float(1000)/float(fps)))) if start_time > 0.0 else 0
+        self.end_frame = int(round(float(end_time)/(float(1000)/float(fps)))) if end_time > 0.0 and start_time < end_time else -1
 
-        start_frame = int(round(float(start_time)/(float(1000)/float(fps)))) if start_time > 0.0 else 0
-        end_frame = int(round(float(end_time)/(float(1000)/float(fps)))) if end_time > 0.0 and start_time < end_time else -1
+        self.__logger.info("Set End Time to Frame Number %d", self.end_frame)
 
-        self.__logger.info("Set End Time to Frame Number %d", end_frame)
-
-        self.funscript_generator = FunscriptGeneratorThread(
-                FunscriptGeneratorParameter(
-                    video_path = video_file,
-                    start_frame = start_frame,
-                    end_frame = end_frame,
-                    track_men = trackMen
-                ),
-                self.funscript)
-        self.funscript_generator.funscriptCompleted.connect(self.__funscript_generated)
+        self.settings = {}
+        self.settings_dialog = SettingsDialog(self.settings)
+        self.settings_dialog.applySettings.connect(self.run)
+        self.settings_dialog.show()
 
 
     __logger = logging.getLogger(__name__)
@@ -110,10 +95,24 @@ def __funscript_generated(self, funscript, msg, success) -> None:
                 f.write('at;pos\n')
                 for item in funscript.get_actions():
                     f.write('{at};{pos}\n'.format(at=item['at'], pos=item['pos']))
+
+            self.__logger.info("Save result to %s", self.output_file)
             if not success: self.__show_message(msg, error=True)
             sys.exit()
 
 
     def run(self) -> None:
         """ start generator """
+        self.__logger.info('settings: %s', str(self.settings))
+        self.funscript_generator = FunscriptGeneratorThread(
+                FunscriptGeneratorParameter(
+                    video_path = self.video_file,
+                    track_men = self.settings['trackingMethod'] != 'Woman',
+                    direction = self.settings['trackingAxis'],
+                    projection = self.settings['videoType'],
+                    start_frame = self.start_frame,
+                    end_frame = self.end_frame
+                ),
+                self.funscript)
+        self.funscript_generator.funscriptCompleted.connect(self.__funscript_generated)
         self.funscript_generator.start()
diff --git a/funscript_editor/ui/settings_dialog.py b/funscript_editor/ui/settings_dialog.py
@@ -0,0 +1,52 @@
+""" Settings Dialog for the Funscript Generator """
+
+import funscript_editor.ui.settings_view as settings_view
+
+from funscript_editor.utils.config import PROJECTION
+
+from PyQt5 import QtWidgets, QtCore, QtGui
+
+class SettingsDialog(QtWidgets.QDialog):
+    """ Settings Dialog
+
+    Args:
+        settings (dict): dict where to store the settings
+    """
+
+    def __init__(self, settings):
+        super(SettingsDialog, self).__init__()
+        self.ui = settings_view.Ui_Form()
+        self.form = QtWidgets.QDialog()
+        self.ui.setupUi(self.form)
+        self.form.setWindowTitle("Settings")
+        self.settings = settings
+        self.__setup_ui_bindings()
+        self.__setup_combo_boxes()
+
+    #: apply settiongs event
+    applySettings = QtCore.pyqtSignal()
+
+    def show(self):
+        """ Show wttings dialog """
+        self.form.show()
+
+    def __setup_ui_bindings(self):
+        self.ui.okButton.clicked.connect(self.__apply)
+        self.ui.videoTypeComboBox.currentTextChanged.connect(
+                lambda value: self.__set_setting(
+                    'videoType',
+                    list(filter(lambda x: PROJECTION[x]['name'] == value, PROJECTION.keys()))[0]))
+        self.ui.trackingAxisComboBox.currentTextChanged.connect(lambda value: self.__set_setting('trackingAxis', value))
+        self.ui.trackingMethodComboBox.currentTextChanged.connect(lambda value: self.__set_setting('trackingMethod', value))
+
+    def __setup_combo_boxes(self):
+        self.ui.videoTypeComboBox.addItems([PROJECTION[key]['name'] for key in PROJECTION.keys()])
+        self.ui.trackingAxisComboBox.addItems(['y', 'x'])
+        self.ui.trackingMethodComboBox.addItems(['Woman', 'Woman + Men'])
+
+    def __apply(self):
+        self.form.hide()
+        self.applySettings.emit()
+
+    def __set_setting(self, key, value):
+        self.settings[key] = value
diff --git a/funscript_editor/ui/settings_view.py b/funscript_editor/ui/settings_view.py
@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'settings_view.ui'
+#
+# Created by: PyQt5 UI code generator 5.15.4
+#
+# WARNING: Any manual changes made to this file will be lost when pyuic5 is
+# run again.  Do not edit this file unless you know what you are doing.
+
+
+from PyQt5 import QtCore, QtGui, QtWidgets
+
+
+class Ui_Form(object):
+    def setupUi(self, Form):
+        Form.setObjectName("Form")
+        Form.resize(300, 220)
+        self.gridLayout_4 = QtWidgets.QGridLayout(Form)
+        self.gridLayout_4.setSizeConstraint(QtWidgets.QLayout.SetDefaultConstraint)
+        self.gridLayout_4.setContentsMargins(-1, 6, 6, 6)
+        self.gridLayout_4.setSpacing(6)
+        self.gridLayout_4.setObjectName("gridLayout_4")
+        spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
+        self.gridLayout_4.addItem(spacerItem, 2, 0, 1, 1)
+        self.formLayout = QtWidgets.QFormLayout()
+        self.formLayout.setObjectName("formLayout")
+        self.label = QtWidgets.QLabel(Form)
+        self.label.setObjectName("label")
+        self.formLayout.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.label)
+        self.videoTypeComboBox = QtWidgets.QComboBox(Form)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.videoTypeComboBox.sizePolicy().hasHeightForWidth())
+        self.videoTypeComboBox.setSizePolicy(sizePolicy)
+        self.videoTypeComboBox.setObjectName("videoTypeComboBox")
+        self.formLayout.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.videoTypeComboBox)
+        self.label_2 = QtWidgets.QLabel(Form)
+        self.label_2.setObjectName("label_2")
+        self.formLayout.setWidget(2, QtWidgets.QFormLayout.LabelRole, self.label_2)
+        self.label_3 = QtWidgets.QLabel(Form)
+        self.label_3.setObjectName("label_3")
+        self.formLayout.setWidget(3, QtWidgets.QFormLayout.LabelRole, self.label_3)
+        self.trackingAxisComboBox = QtWidgets.QComboBox(Form)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.trackingAxisComboBox.sizePolicy().hasHeightForWidth())
+        self.trackingAxisComboBox.setSizePolicy(sizePolicy)
+        self.trackingAxisComboBox.setObjectName("trackingAxisComboBox")
+        self.formLayout.setWidget(2, QtWidgets.QFormLayout.FieldRole, self.trackingAxisComboBox)
+        self.trackingMethodComboBox = QtWidgets.QComboBox(Form)
+        sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.trackingMethodComboBox.sizePolicy().hasHeightForWidth())
+        self.trackingMethodComboBox.setSizePolicy(sizePolicy)
+        self.trackingMethodComboBox.setObjectName("trackingMethodComboBox")
+        self.formLayout.setWidget(3, QtWidgets.QFormLayout.FieldRole, self.trackingMethodComboBox)
+        self.horizontalLayout = QtWidgets.QHBoxLayout()
+        self.horizontalLayout.setObjectName("horizontalLayout")
+        spacerItem1 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
+        self.horizontalLayout.addItem(spacerItem1)
+        self.okButton = QtWidgets.QPushButton(Form)
+        self.okButton.setObjectName("okButton")
+        self.horizontalLayout.addWidget(self.okButton)
+        self.formLayout.setLayout(4, QtWidgets.QFormLayout.FieldRole, self.horizontalLayout)
+        self.label_4 = QtWidgets.QLabel(Form)
+        font = QtGui.QFont()
+        font.setBold(False)
+        font.setWeight(50)
+        self.label_4.setFont(font)
+        self.label_4.setObjectName("label_4")
+        self.formLayout.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.label_4)
+        self.gridLayout_4.addLayout(self.formLayout, 1, 0, 1, 1)
+        spacerItem2 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
+        self.gridLayout_4.addItem(spacerItem2, 0, 0, 1, 1)
+
+        self.retranslateUi(Form)
+        QtCore.QMetaObject.connectSlotsByName(Form)
+
+    def retranslateUi(self, Form):
+        _translate = QtCore.QCoreApplication.translate
+        Form.setWindowTitle(_translate("Form", "Form"))
+        self.label.setText(_translate("Form", "Video Type:"))
+        self.label_2.setText(_translate("Form", "Tracking Axis:"))
+        self.label_3.setText(_translate("Form", "Tracking Method:"))
+        self.okButton.setText(_translate("Form", "OK"))
+        self.label_4.setText(_translate("Form", "  # Settings"))
diff --git a/funscript_editor/ui/settings_view.ui b/funscript_editor/ui/settings_view.ui
