reimplement scaling part 3

Author: arch

funscript_editor/algorithms/funscriptgenerator.py

@@ -66,20 +66,18 @@ def __init__(self,
         self.window_name = "Funscript Generator ({})".format(datetime.now().strftime("%H:%M:%S"))
 
         self.keypress_queue = Queue(maxsize=32)
-        self.stopped = False
-        self.perspective_params = {}
         self.x_text_start = 50
+        self.font_size = 0.6
+        self.tracking_fps = []
         self.scone_x = []
         self.scone_y = []
         self.bboxes = {
                 'Men': [],
                 'Woman': []
                 }
 
-        cap = cv2.VideoCapture(self.params.video_path)
-        self.fps = cap.get(cv2.CAP_PROP_FPS)
-        self.tracking_fps = []
-        cap.release()
+        self.video_info = FFmpegStream.get_video_info(self.params.video_path)
+
 
     #: completed event with reference to the funscript with the predicted actions, status message and success flag
     funscriptCompleted = QtCore.pyqtSignal(object, str, bool)
@@ -90,22 +88,25 @@ def __init__(self,
     logger = logging.getLogger(__name__)
 
 
-    def determine_monitor_scaling(self):
-        frame_width = PROJECTION[self.params.projection]['parameter']['width']
-        frame_height = PROJECTION[self.params.projection]['parameter']['height']
+    def determine_monitor_scaling(self, frame_width, frame_height) -> float:
+        """ Determine the scaling for current monitor setup
 
+        Args:
+            frame_width (int): target frame width
+            frame_height (int): target frame height
+        """
         scale = []
         try:
             for monitor in get_monitors():
-                scale.append( min((monitor.width / float(frame_width), monitor.height / float(frame_height) )) )
+                if monitor.width > monitor.height:
+                    scale.append( min((monitor.width / float(frame_width), monitor.height / float(frame_height) )) )
         except: pass
 
         if len(scale) == 0:
             self.logger.error("Monitor resolution info not found")
-            self.monitor_scale = 1.0
         else:
             # asume we use the largest monitor for scipting
-            self.mointor_scale = max(scale)
+            self.params.preview_scaling *= max(scale)
 
 
     def drawBox(self, img: np.ndarray, bbox: tuple) -> np.ndarray:
@@ -136,7 +137,7 @@ def drawFPS(self, img: np.ndarray) -> np.ndarray:
         fps = (self.params.skip_frames+1)*cv2.getTickFrequency()/(cv2.getTickCount()-self.timer)
         self.tracking_fps.append(fps)
         cv2.putText(annotated_img, str(int(fps)) + ' fps', (self.x_text_start, 50),
-                cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)
+                cv2.FONT_HERSHEY_SIMPLEX, self.font_size, (0,0,255), 2)
         self.timer = cv2.getTickCount()
         return annotated_img
 
@@ -154,7 +155,7 @@ def drawText(self, img: np.ndarray, txt: str, y :int = 50, color :tuple = (0,0,2
             np.ndarray: opencv image with text
         """
         annotated_img = img.copy()
-        cv2.putText(annotated_img, str(txt), (self.x_text_start, y), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
+        cv2.putText(annotated_img, str(txt), (self.x_text_start, y), cv2.FONT_HERSHEY_SIMPLEX, self.font_size, color, 2)
         return annotated_img
 
 
@@ -212,17 +213,17 @@ def min_max_selector(self,
         image = np.concatenate((image_min, image_max), axis=1)
 
         if info != "":
-            cv2.putText(image, "Info: "+info, (self.x_text_start, 75), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,0,0), 2)
+            cv2.putText(image, "Info: "+info, (self.x_text_start, 75), cv2.FONT_HERSHEY_SIMPLEX, self.font_size, (255,0,0), 2)
 
         if title_min != "":
-            cv2.putText(image, title_min, (self.x_text_start, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,0,0), 2)
+            cv2.putText(image, title_min, (self.x_text_start, 25), cv2.FONT_HERSHEY_SIMPLEX, self.font_size, (255,0,0), 2)
 
         if title_max != "":
             cv2.putText(image, title_max, (image_min.shape[1] + self.x_text_start, 25),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,0,0), 2)
+                    cv2.FONT_HERSHEY_SIMPLEX, self.font_size, (255,0,0), 2)
 
         cv2.putText(image, "Use 'space' to quit and set the trackbar values",
-            (self.x_text_start, 100), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,0,0), 2)
+            (self.x_text_start, 100), cv2.FONT_HERSHEY_SIMPLEX, self.font_size, (255,0,0), 2)
 
         self.clear_keypress_queue()
         trackbarValueMin = lower_limit
@@ -231,9 +232,9 @@ def min_max_selector(self,
             try:
                 preview = image.copy()
                 cv2.putText(preview, "Set {} to {}".format('Min', trackbarValueMin),
-                    (self.x_text_start, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)
+                    (self.x_text_start, 50), cv2.FONT_HERSHEY_SIMPLEX, self.font_size, (0,0,255), 2)
                 cv2.putText(preview, "Set {} to {}".format('Max', trackbarValueMax),
-                    (image_min.shape[1] + self.x_text_start, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)
+                    (image_min.shape[1] + self.x_text_start, 50), cv2.FONT_HERSHEY_SIMPLEX, self.font_size, (0,0,255), 2)
                 cv2.imshow(self.window_name, self.preview_scaling(preview))
                 if self.was_space_pressed() or cv2.waitKey(25) == ord(' '): break
                 trackbarValueMin = cv2.getTrackbarPos("Min", self.window_name)
@@ -411,7 +412,12 @@ def preview_scaling(self, preview_image :np.ndarray) -> np.ndarray:
         Returns:
             np.ndarray: scaled opencv image
         """
-        return cv2.resize(preview_image, None, fx=self.params.preview_scaling, fy=self.params.preview_scaling)
+        return cv2.resize(
+                preview_image,
+                None,
+                fx=self.params.preview_scaling,
+                fy=self.params.preview_scaling
+            )
 
 
     def get_vr_projection_config(self, image :np.ndarray) -> None:
@@ -422,6 +428,8 @@ def get_vr_projection_config(self, image :np.ndarray) -> None:
         """
         config = PROJECTION[self.params.projection]
 
+        self.mointor_scale = self.determine_monitor_scaling(config['parameter']['width'], config['parameter']['height'])
+
         # NOTE: improve processing speed to make this menu more responsive
         if image.shape[0] > 6000 or image.shape[1] > 6000:
             image = cv2.resize(image, None, fx=0.25, fy=0.25)
@@ -549,6 +557,8 @@ def get_flat_projection_config(self,
             scaling = config['parameter']['height'] / float(h)
             config['parameter']['width'] = round(w * scaling)
 
+        self.mointor_scale = self.determine_monitor_scaling(config['parameter']['width'], config['parameter']['height'])
+
         return config
 
 
@@ -622,7 +632,7 @@ def tracking(self) -> str:
 
                 last_frame = self.drawFPS(last_frame)
                 cv2.putText(last_frame, "Press 'q' if the tracking point shifts or a video cut occured",
-                        (self.x_text_start, 75), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,0,0), 2)
+                        (self.x_text_start, 75), cv2.FONT_HERSHEY_SIMPLEX, self.font_size, (255,0,0), 2)
                 cv2.imshow(self.window_name, self.preview_scaling(last_frame))
 
                 if self.was_key_pressed('q') or cv2.waitKey(1) == ord('q'):
@@ -706,7 +716,6 @@ def finished(self, status: str, success :bool) -> None:
         """
         cv2.destroyWindow(self.window_name)
         self.funscriptCompleted.emit(self.funscript, status, success)
-        self.stopped = True
 
 
     def apply_shift(self, frame_number, position: str) -> int:
@@ -727,6 +736,7 @@ def apply_shift(self, frame_number, position: str) -> int:
 
         return self.params.start_frame + frame_number
 
+
     def get_score_with_offset(self, idx_dict) -> list:
         """ Apply the offsets form config file
 
@@ -766,9 +776,9 @@ def run(self) -> None:
             return
 
         if self.params.direction != 'x':
-            idx_dict = sp.get_local_max_and_min_idx(self.score_y, self.fps)
+            idx_dict = sp.get_local_max_and_min_idx(self.score_y, self.video_info.fps)
         else:
-            idx_dict = sp.get_local_max_and_min_idx(self.score_x, self.fps)
+            idx_dict = sp.get_local_max_and_min_idx(self.score_x, self.video_info.fps)
 
         idx_list = [x for k in ['min', 'max'] for x in idx_dict[k]]
         idx_list.sort()
@@ -784,15 +794,15 @@ def run(self) -> None:
                     min(output_score) \
                             if output_score[idx] < min(output_score) + self.params.bottom_threshold \
                             else round(output_score[idx]),
-                    self.frame_to_millisec(self.apply_shift(idx, 'min'), self.fps)
+                    self.frame_to_millisec(self.apply_shift(idx, 'min'), self.video_info.fps)
                 )
 
         for idx in idx_dict['max']:
             self.funscript.add_action(
                     max(output_score) \
                             if output_score[idx] > max(output_score) - self.params.top_threshold \
                             else round(output_score[idx]),
-                    self.frame_to_millisec(self.apply_shift(idx, 'max'), self.fps)
+                    self.frame_to_millisec(self.apply_shift(idx, 'max'), self.video_info.fps)
                 )
 
         self.finished(status, True)

funscript_editor/config/projection.yaml

@@ -1,5 +1,7 @@
+# projection config
+# do not change any parameter here!
 
-# 3D Side-By-Side VR Video
+# 3D Side-By-Side 180 Dome VR Videos
 vr_he_sbs:
   video_filter: 'v360=input=he:in_stereo=sbs:pitch=${phi}:output=flat:d_fov=${fov}:w=${width}:h=${height}'
   parameter:
@@ -8,6 +10,7 @@ vr_he_sbs:
     fov: 100
     phi: -45
 
+# 2D Videos
 flat:
   video_filter: 'scale=${width}:${height}'
   parameter:

funscript_editor/config/settings.yaml

@@ -13,9 +13,8 @@ tracking_direction: 'y'
 # Limit the max player speed in the tracking preview window (0 = disable limit)
 max_playback_fps: 0
 
-# TODO
-preview_scaling: 1.0
+# Set the preview image scaling factor 1.0 should match your monitor size
+preview_scaling: 0.66
 
-# TODO
-# projection: 'vr_he_sbs'
-projection: 'flat'
+# Set the video type
+projection: 'vr_he_sbs'