Extract clip as video, slp and pkg.slp

sleap/gui/app.py

@@ -746,6 +746,22 @@ def new_instance_menu_action():
 
         labelMenu.addSeparator()
 
+        add_menu_item(
+            labelMenu,
+            "Extract clip and labels",
+            "Extract Clip and Labels...",
+            self.commands.exportClipVideo,
+        )
+
+        add_menu_item(
+            labelMenu,
+            "extract clip labels package",
+            "Extract Clip Labels Package...",
+            self.commands.exportClipPkg,
+        )
+
+        labelMenu.addSeparator()
+
         add_menu_item(
             labelMenu,
             "add instances from all frame predictions",

sleap/gui/commands.py

@@ -49,6 +49,7 @@ class which inherits from `AppCommand` (or a more specialized class such as
 from sleap.gui.dialogs.merge import MergeDialog, ReplaceSkeletonTableDialog
 from sleap.gui.dialogs.message import MessageDialog
 from sleap.gui.dialogs.missingfiles import MissingFilesDialog
+from sleap.gui.dialogs.export_clip import ExportClipAndLabelsDialog
 from sleap.gui.state import GuiState
 from sleap.gui.suggestions import VideoFrameSuggestions
 from sleap.instance import Instance, LabeledFrame, Point, PredictedInstance, Track
@@ -57,10 +58,12 @@ class which inherits from `AppCommand` (or a more specialized class such as
 from sleap.io.format.adaptor import Adaptor
 from sleap.io.format.csv import CSVAdaptor
 from sleap.io.format.ndx_pose import NDXPoseAdaptor
-from sleap.io.video import Video
+from sleap.io.video import Video, MediaVideo
+from sleap.io.videowriter import VideoWriter
 from sleap.skeleton import Node, Skeleton
 from sleap.util import get_package_file
 
+
 # Indicates whether we support multiple project windows (i.e., "open" opens new window)
 OPEN_IN_NEW = True
 
@@ -627,6 +630,14 @@ def openPrereleaseVersion(self):
         """Open the current prerelease version."""
         self.execute(OpenPrereleaseVersion)
 
+    def exportClipVideo(self):
+        """Exports a selected range of video frames and their corresponding labels."""
+        self.execute(ExportClipVideo)
+
+    def exportClipPkg(self):
+        """Exports a selected range of video frames and their corresponding labels."""
+        self.execute(ExportClipPkg)
+
 
 # File Commands
 
@@ -3470,13 +3481,184 @@ def do_action(context: CommandContext, params: dict):
         if rls is not None:
             context.openWebsite(rls.url)
 
+class ExportClipVideo(AppCommand):
+    @staticmethod
+    def do_action(context: CommandContext, params: dict):
+        """
+        Exports a pruned video clip and labels to a specified file based on selected frame range.
 
-def copy_to_clipboard(text: str):
-    """Copy a string to the system clipboard.
+        Args:
+            context (CommandContext): Contains state information like video and labels.
+            params (dict): Parameters including filename, fps, and open_when_done.
+        """
+        # Extract video and labels from context
+        video = context.state["video"]
+        labels = context.state["labels"]
+
+        # Ensure frame range is set; default to all frames if None
+        frame_range = context.state.get("frame_range", (0, video.frames))
+
+        # Check if clip is selected, raise error if no clip selected
+        if frame_range == (0, video.frames) or frame_range == (0, 1):
+             raise ValueError("No valid clip frame range selected! Please select a valid frame range using shift + click in the GUI.")
+
+        # Extract only the selected frames into a new Labels object
+        pruned_labels = labels.extract(
+            inds=range(*frame_range),
+            copy=True,  # Ensures a deep copy of the extracted labels
+        )
 
-    Args:
-        text: String to copy to clipboard.
-    """
-    clipboard = QtWidgets.QApplication.clipboard()
-    clipboard.clear(mode=clipboard.Clipboard)
-    clipboard.setText(text, mode=clipboard.Clipboard)
+        # Remap frame indices in pruned_labels to start from 0
+        for labeled_frame in pruned_labels.labeled_frames:
+            labeled_frame.frame_idx -= frame_range[0]
+
+        # Initialize VideoWriter
+        height, width = video.height, video.width
+        fps = params["fps"]
+        writer = VideoWriter.safe_builder(params["filename"], height, width, fps)
+
+        # Write frames to the video
+        for frame_idx in range(*frame_range):
+            try:
+                frame = video.get_frame(frame_idx)
+
+                # Convert grayscale to BGR if necessary
+                if frame.ndim == 2:  # Grayscale frames
+                    frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)
+
+                writer.add_frame(frame, bgr=True)
+            except KeyError:
+                raise KeyError(f"Failed to load frame {frame_idx} from video.")
+
+        writer.close()
+
+        # Create a new Video object for the output video
+        new_media_video = MediaVideo(
+            filename=params["filename"], grayscale=video.channels == 1, bgr=True
+        )
+        new_video = Video(backend=new_media_video)
+
+        # Update pruned labels to point to the new video
+        for labeled_frame in pruned_labels.labeled_frames:
+            labeled_frame.video = new_video
+
+        pruned_labels.videos = [new_video]
+
+        # Save the pruned labels
+        labels_filename = params["filename"].replace(".mp4", ".slp")
+        pruned_labels.save(labels_filename)
+
+        # Open the video file when done, if specified
+        if params.get("open_when_done", False):
+            open_file(params["filename"])
+
+    @staticmethod
+    def ask(context: CommandContext, params: dict) -> bool:
+        """
+        Asks the user for export parameters via a custom dialog.
+
+        Args:
+            context: Command context, providing state and application access.
+            params: A dictionary to populate with user-defined options.
+
+        Returns:
+            bool: True if the user confirmed the action, False if canceled.
+        """
+
+        # Extract FPS from video metadata (fallback to 30 if unavailable)
+        video_fps = getattr(context.state["video"], "fps", 30)
+
+        # Initialize and show the export dialog
+        dialog = ExportClipAndLabelsDialog(video_fps=video_fps)
+        if dialog.exec_() != QtWidgets.QDialog.Accepted:
+            return False  # User canceled
+
+        # Get user input from dialog
+        export_options = dialog.get_results()
+
+        # Prompt user to select output file
+        filename, _ = QtWidgets.QFileDialog.getSaveFileName(
+            None, "Save Clip As...", "", "Video (*.mp4 *.avi)"
+        )
+        if not filename:
+            return False  # User canceled file selection
+
+        # Populate export parameters
+        params["filename"] = filename
+        params["fps"] = export_options["fps"]
+        params["open_when_done"] = export_options["open_when_done"]
+
+        # Access frame range
+        if context.state.get("has_frame_range"):
+            params["frames"] = range(*context.state["frame_range"])
+        else:
+            params["frames"] = range(context.state["video"].frames)
+
+        return True
+
+    def copy_to_clipboard(text: str):
+        """Copy a string to the system clipboard.
+
+        Args:
+            text: String to copy to clipboard.
+        """
+        clipboard = QtWidgets.QApplication.clipboard()
+        clipboard.clear(mode=clipboard.Clipboard)
+        clipboard.setText(text, mode=clipboard.Clipboard)
+
+class ExportClipPkg(AppCommand):
+    @staticmethod
+    def do_action(context: CommandContext, params: dict):
+        """
+        Exports a pruned labels package based on selected frame range.
+
+        Args:
+            context (CommandContext): Contains state information like video and labels.
+            params (dict): Parameters including filename, fps, and open_when_done.
+        """
+        # Extract video and labels from context
+        video = context.state["video"]
+        labels = context.state["labels"]
+
+        # Ensure frame range is set; default to all frames if None
+        frame_range = context.state.get("frame_range", (0, video.frames))
+
+        # Check if clip is selected, raise error if no clip selected
+        if frame_range == (0, video.frames) or frame_range == (0, 1):
+             raise ValueError("No valid clip frame range selected! Please select a valid frame range using shift + click in the GUI.")
+
+        # Extract only the selected frames into a new Labels object
+        pruned_labels = labels.extract(
+            inds=range(*frame_range),
+            copy=True,  # Ensures a deep copy of the extracted labels
+        )
+
+        # Remap frame indices in pruned_labels to start from 0
+        for labeled_frame in pruned_labels.labeled_frames:
+            labeled_frame.frame_idx -= frame_range[0]
+
+        pkg_filename = params["filename"]
+        pruned_labels.save(pkg_filename, with_images=True)
+
+    @staticmethod
+    def ask(context: CommandContext, params: dict) -> bool:
+        """
+        Asks the user for export parameters via a custom dialog.
+
+        Args:
+            context: Command context, providing state and application access.
+            params: A dictionary to populate with user-defined options.
+
+        Returns:
+            bool: True if the user confirmed the action, False if canceled.
+        """
+
+        # Prompt user to select output file
+        filename, _ = QtWidgets.QFileDialog.getSaveFileName(
+            None, "Save Clip Package As...", "", "Label Package (*.pkg.slp)"
+        )
+        if not filename:
+            return False  # User canceled file selection
+         # Update the params dictionary with the selected filename
+        params["filename"] = filename
+        return True

sleap/gui/dialogs/export_clip.py

@@ -3,6 +3,7 @@
 """
 
 from sleap.gui.dialogs.formbuilder import FormBuilderModalDialog
+from qtpy import QtWidgets
 
 
 class ExportClipDialog(FormBuilderModalDialog):
@@ -27,3 +28,54 @@ def __init__(self):
         self.add_message(message)
 
         self.setWindowTitle("Export Clip Options")
+
+
+class ExportClipAndLabelsDialog(FormBuilderModalDialog):
+    def __init__(self, video_fps=30):
+        from sleap.io.videowriter import VideoWriter
+
+        # Initialize with a blank widget (no YAML needed)
+        super().__init__(form_widget=QtWidgets.QWidget())
+
+        self.setWindowTitle("Export Clip Options")
+
+        # FPS Field
+        self.fps_input = QtWidgets.QSpinBox()
+        self.fps_input.setRange(1, 240)
+        self.fps_input.setValue(video_fps)  # Set default FPS from video
+        self.add_message("Frames per second:")
+        self.layout().insertWidget(2, self.fps_input)
+
+        # Open when done Checkbox
+        self.open_when_done = QtWidgets.QCheckBox("Open file after saving")
+        self.layout().insertWidget(3, self.open_when_done)
+
+        # Video format message
+        can_use_ffmpeg = VideoWriter.can_use_ffmpeg()
+        if can_use_ffmpeg:
+            message = (
+                "<i><b>MP4</b> file will be encoded using "
+                "system ffmpeg via imageio (preferred option).</i>"
+            )
+        else:
+            message = (
+                "<i>Unable to use ffmpeg via imageio. "
+                "<b>AVI</b> file will be encoded using OpenCV.</i>"
+            )
+        self.add_message(message)
+
+    def on_accept(self):
+        """Retrieve the form results and accept the dialog."""
+        self._results = {
+            "fps": self.fps_input.value(),
+            "open_when_done": self.open_when_done.isChecked(),
+        }
+        self.accept()
+
+    def get_results(self):
+        """Get results as a dictionary."""
+        self._results = {
+            "fps": self.fps_input.value(),
+            "open_when_done": self.open_when_done.isChecked(),
+        }
+        return self._results