Effect parenting

src/classes/effect_init.py

@@ -25,7 +25,8 @@
  You should have received a copy of the GNU General Public License
  along with OpenShot Library.  If not, see <http://www.gnu.org/licenses/>.
  """
-
+from classes.info import USER_PATH
+import os
 # Not all Effects support pre-processing, so for now, this is a hard-coded
 # solution to providing the pre-processing params needed for these special effects.
 
@@ -150,19 +151,19 @@
 
     "Object Detector": [
         {
-            "value": "../yolo/yolov3.weights",
+            "value": os.path.join(USER_PATH,"yolo/yolov3.weights"),
             "title": "Model Weights",
             "type": "text",
             "setting": "model-weights"
         },
         {
-            "value": "../yolo/yolov3.cfg",
+            "value": os.path.join(USER_PATH,"yolo/yolov3.cfg"),
             "title": "Model Config",
             "type": "text",
             "setting": "model-config"
         },
         {
-            "value": "../yolo/obj.names",
+            "value": os.path.join(USER_PATH,"yolo/obj.names"),
             "title": "Class names",
             "type": "text",
             "setting": "class-names"

src/classes/project_data.py

@@ -407,6 +407,58 @@ def rescale_keyframes(self, scale_factor):
         scaled = scaler(copy.deepcopy(self._data))
         return scaled
 
+        # Create copy of active project data
+        data = copy.deepcopy(self._data)
+
+        # Rescale the the copied project data
+        # Loop through all clips (and look for Keyframe objects)
+        # Scale the X coordinate by factor (which represents the frame #)
+        for clip in data.get('clips', []):
+            for attribute in clip:
+                if type(clip.get(attribute)) == dict and "Points" in clip.get(attribute):
+                    for point in clip.get(attribute).get("Points"):
+                        if "co" in point:
+                            point["co"]["X"] = self.scale_keyframe_value(point["co"].get("X", 0.0), scale_factor)
+                if type(clip.get(attribute)) == dict and "red" in clip.get(attribute):
+                    for color in clip.get(attribute):
+                        for point in clip.get(attribute).get(color).get("Points"):
+                            if "co" in point:
+                                point["co"]["X"] = self.scale_keyframe_value(point["co"].get("X", 0.0), scale_factor)
+            for effect in clip.get("effects", []):
+                for attribute in effect:
+                    if type(effect.get(attribute)) == dict and "Points" in effect.get(attribute):
+                        for point in effect.get(attribute).get("Points"):
+                            if "co" in point:
+                                point["co"]["X"] = self.scale_keyframe_value(point["co"].get("X", 0.0), scale_factor)
+                    if type(effect.get(attribute)) == dict and "red" in effect.get(attribute):
+                        for color in effect.get(attribute):
+                            for point in effect.get(attribute).get(color).get("Points"):
+                                if "co" in point:
+                                    point["co"]["X"] = self.scale_keyframe_value(point["co"].get("X", 0.0), scale_factor)
+                if effect.get("class_name") == "Tracker":
+                        effect["TimeScale"] = effect["TimeScale"] * scale_factor
+
+
+        # Loop through all effects/transitions (and look for Keyframe objects)
+        # Scale the X coordinate by factor (which represents the frame #)
+        for effect in data.get('effects', []):
+            for attribute in effect:
+                if type(effect.get(attribute)) == dict and "Points" in effect.get(attribute):
+                    for point in effect.get(attribute).get("Points"):
+                        if "co" in point:
+                            point["co"]["X"] = self.scale_keyframe_value(point["co"].get("X", 0.0), scale_factor)
+                if type(effect.get(attribute)) == dict and "red" in effect.get(attribute):
+                    for color in effect.get(attribute):
+                        for point in effect.get(attribute).get(color).get("Points"):
+                            if "co" in point:
+                                point["co"]["X"] = self.scale_keyframe_value(point["co"].get("X", 0.0), scale_factor)
+            if effect.get("class_name") == "Tracker":
+                effect["TimeScale"] = effect["TimeScale"] * scale_factor
+
+
+        # return the copied and scaled project data
+        return data
+
     def read_legacy_project_file(self, file_path):
         """Attempt to read a legacy version 1.x openshot project file"""
         import sys

src/windows/main_window.py

@@ -58,7 +58,7 @@
 from classes.importers.final_cut_pro import import_xml
 from classes.logger import log
 from classes.metrics import track_metric_session, track_metric_screen
-from classes.query import Clip, Transition, Marker, Track
+from classes.query import Clip, Transition, Marker, Track, Effect
 from classes.thumbnail import httpThumbnailServerThread
 from classes.time_parts import secondsToTimecode
 from classes.timeline import TimelineSync
@@ -101,6 +101,7 @@ class MainWindow(updates.UpdateWatcher, QMainWindow):
     FoundVersionSignal = pyqtSignal(str)
     WaveformReady = pyqtSignal(str, list)
     TransformSignal = pyqtSignal(str)
+    KeyFrameTransformSignal = pyqtSignal(str, str)
     SelectRegionSignal = pyqtSignal(str)
     MaxSizeChanged = pyqtSignal(object)
     InsertKeyframe = pyqtSignal(object)
@@ -2282,6 +2283,14 @@ def addSelection(self, item_id, item_type, clear_existing=False):
             elif item_type == "effect" and item_id not in self.selected_effects:
                 self.selected_effects.append(item_id)
 
+                effect = Effect.get(id=item_id)
+                if effect:
+                    if effect.data.get("has_tracked_object"):
+                        # Show bounding boxes transform on preview
+                        clip_id = effect.parent['id']
+                        self.KeyFrameTransformSignal.emit(item_id, clip_id)
+
+
             # Change selected item in properties view
             self.show_property_id = item_id
             self.show_property_type = item_type

src/windows/process_effect.py

@@ -255,6 +255,12 @@ def rect_select_clicked(self, widget, param):
                 topLeft = win.videoPreview.regionTopLeftHandle
                 bottomRight = win.videoPreview.regionBottomRightHandle
                 viewPortSize = win.viewport_rect
+                curr_frame_size = win.videoPreview.curr_frame_size
+
+                x1 = topLeft.x() / curr_frame_size.width()
+                y1 = topLeft.y() / curr_frame_size.height()
+                x2 = bottomRight.x() / curr_frame_size.width()
+                y2 = bottomRight.y() / curr_frame_size.height()
 
                 # Get QImage of region
                 if win.videoPreview.region_qimage:
@@ -275,13 +281,10 @@ def rect_select_clicked(self, widget, param):
 
                 # If data found, add to context
                 if topLeft and bottomRight:
-                    self.context[param["setting"]].update({"x": topLeft.x(), "y": topLeft.y(),
-                                                           "width": bottomRight.x() - topLeft.x(),
-                                                           "height": bottomRight.y() - topLeft.y(),
-                                                           "scaled_x": topLeft.x() / viewPortSize.width(), "scaled_y": topLeft.y() / viewPortSize.height(),
-                                                           "scaled_width": (bottomRight.x() - topLeft.x()) / viewPortSize.width(),
-                                                           "scaled_height": (bottomRight.y() - topLeft.y()) / viewPortSize.height(),
-                                                           "first-frame": win.current_frame
+                    self.context[param["setting"]].update({"normalized_x": x1, "normalized_y": y1,
+                                                           "normalized_width": x2-x1,
+                                                           "normalized_height": y2-y1,
+                                                           "first-frame": win.current_frame,
                                                            })
                     log.info(self.context)
 
@@ -344,11 +347,15 @@ def accept(self):
             if(self.cancel_clip_processing):
                 processing.CancelProcessing()
 
+        fps = get_app().project.get("fps")
+
         if(not self.cancel_clip_processing):
 
             # Load processed data into effect
             self.effect = openshot.EffectInfo().CreateEffect(self.effect_name)
+
             self.effect.SetJson( '{"protobuf_data_path": "%s"}' % protobufPath )
+
             self.effect.Id(ID)
 
             # Accept dialog

src/windows/region.py

@@ -119,8 +119,13 @@ def __init__(self, file=None, clip=None):
         self.videoPreview.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
         self.verticalLayout.insertWidget(0, self.videoPreview)
 
+        # Set aspect ratio to match source content
+        aspect_ratio = openshot.Fraction(self.width, self.height)
+        aspect_ratio.Reduce()
+        self.videoPreview.aspect_ratio = aspect_ratio
+
         # Set max size of video preview (for speed)
-        self.viewport_rect = self.videoPreview.centeredViewport(self.videoPreview.width(), self.videoPreview.height())
+        self.viewport_rect = self.videoPreview.centeredViewport(self.width, self.height)
 
         # Create an instance of a libopenshot Timeline object
         self.r = openshot.Timeline(self.viewport_rect.width(), self.viewport_rect.height(), openshot.Fraction(self.fps_num, self.fps_den), self.sample_rate, self.channels, self.channel_layout)