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",
@@ -1083,7 +1099,7 @@ def overlay_state_connect(overlay, state_key, overlay_attribute=None):
         self.state.emit("color predicted")
 
     def _update_gui_state(self):
-        """Enable/disable gui items based on current state."""
+        """Enable/disable GUI items based on the current state."""
         has_selected_instance = self.state["instance"] is not None
         has_selected_node = self.state["selected_node"] is not None
         has_selected_edge = self.state["selected_edge"] is not None
@@ -1118,7 +1134,10 @@ def _update_gui_state(self):
         self._menu_actions["delete instance"].setEnabled(has_selected_instance)
 
         self._menu_actions["delete clip predictions"].setEnabled(has_frame_range)
-        # self._menu_actions["export clip"].setEnabled(has_frame_range)
+
+        # Enable/disable "Extract Clip and Labels" and "Extract Clip Labels Package"
+        self._menu_actions["extract clip and labels"].setEnabled(has_frame_range)
+        self._menu_actions["extract clip labels package"].setEnabled(has_frame_range)
 
         self._menu_actions["transpose"].setEnabled(has_multiple_instances)
 

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,230 @@ 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):
+        """
+        Executes the export action for a video clip and its labels.
 
-def copy_to_clipboard(text: str):
-    """Copy a string to the system clipboard.
+        Args:
+            context (CommandContext): The application context containing the current state.
+            params (dict): Parameters for the export, including:
+                - 'filename' (str): The path to save the exported video.
+                - 'fps' (int): Frames per second for the exported video.
+                - 'open_when_done' (bool): Whether to open the video file after exporting.
+
+        Raises:
+            ValueError: If the frame range is invalid or no clip is selected.
+            RuntimeError: If there are issues with video writing or saving labels.
+        """
+        # Extract video and labels from context
+        video = context.state["video"]
+        labels = context.state["labels"]
 
-    Args:
-        text: String to copy to clipboard.
-    """
-    clipboard = QtWidgets.QApplication.clipboard()
-    clipboard.clear(mode=clipboard.Clipboard)
-    clipboard.setText(text, mode=clipboard.Clipboard)
+        # Ensure frame range is set; default to all frames if None
+        frame_range = context.state.get("frame_range", (0, video.frames))
+
+        # Validate frame range
+        if frame_range[0] < 0 or frame_range[1] > video.frames:
+            raise ValueError(f"Frame range {frame_range} is outside video bounds [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) or frame_range[0] == frame_range[1]:
+            raise ValueError("No valid clip frame range selected! Please select a valid frame range using shift + click in the GUI.")
+
+        # Map frame indices to the actual labeled frame objects
+        frame_to_index = {lf.frame_idx: idx for idx, lf in enumerate(labels.labeled_frames) if lf.video == video}
+        valid_frame_indices = [frame for frame in range(*frame_range) if frame in frame_to_index]
+
+        if not valid_frame_indices:
+            raise ValueError("No valid labeled frames found in the selected frame range.")
+
+        # Extract only the selected frames into a new Labels object
+        pruned_labels = labels.extract(
+            inds=[frame_to_index[frame] for frame in valid_frame_indices],
+            copy=True  # Ensures a deep copy of the extracted labels
+        )
+
+        # Remap frame indices in pruned_labels to start from 0 while maintaining spacing
+        frame_offset = frame_range[0]
+        for labeled_frame in pruned_labels.labeled_frames:
+            labeled_frame.frame_idx -= frame_offset
+
+        # Initialize VideoWriter
+        height, width = video.height, video.width
+        fps = params["fps"]
+        writer = VideoWriter.safe_builder(params["filename"], height, width, fps)
+
+        # Conditionally show progress bar
+        show_progress = os.getenv("PYTEST_RUNNING") != "1"
+        if show_progress:
+            app = QtWidgets.QApplication.instance() or QtWidgets.QApplication([])
+            progress = QtWidgets.QProgressDialog("Exporting video...", "Cancel", 0, len(valid_frame_indices))
+            progress.setWindowModality(QtCore.Qt.WindowModal)
+            progress.setValue(0)
+        else:
+            progress = None  # Progress bar disabled during tests
+
+        # Write frames to the video
+        try:
+            for idx, frame_idx in enumerate(valid_frame_indices):
+                if show_progress and progress.wasCanceled():
+                    writer.close()
+                    os.remove(params["filename"])
+                    return
+
+                # Read and process frame
+                try:
+                    frame = video.get_frame(frame_idx)
+                    if frame.ndim == 2:  # Grayscale frames
+                        frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)
+                    writer.add_frame(frame, bgr=True)
+                except Exception as e:
+                    writer.close()
+                    os.remove(params["filename"])
+                    raise RuntimeError(f"Failed to write frame {frame_idx}: {str(e)}")
+
+                # Update progress
+                if show_progress:
+                    progress.setValue(idx + 1)
+                    QtWidgets.QApplication.processEvents()
+
+        finally:
+            writer.close()
+            if show_progress:
+                progress.setValue(len(valid_frame_indices))  # Complete progress
+
+        # 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")
+        try:
+            pruned_labels.save(labels_filename)
+        except Exception as e:
+            raise RuntimeError(f"Failed to save labels to {labels_filename}: {str(e)}")
+
+        # 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("frame_range"):
+            params["frames"] = range(*context.state["frame_range"])
+        else:
+            params["frames"] = range(context.state["video"].frames)
+
+        return True
+
+
+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) or frame_range[0] == frame_range[1]:
+            raise ValueError("No valid clip frame range selected! Please select a valid frame range using shift + click in the GUI.")
+
+        # Map frame indices to the actual labeled frame objects
+        frame_to_index = {lf.frame_idx: idx for idx, lf in enumerate(labels.labeled_frames) if lf.video == video}
+        valid_frame_indices = [frame for frame in range(*frame_range) if frame in frame_to_index]
+
+        if not valid_frame_indices:
+            raise ValueError("No valid labeled frames found in the selected frame range.")
+
+        # Extract only the selected frames into a new Labels object
+        pruned_labels = labels.extract(
+            inds=[frame_to_index[frame] for frame in valid_frame_indices],
+            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]
+
+        try:
+            pkg_filename = params["filename"]
+            pruned_labels.save(pkg_filename, with_images=True)
+        except Exception as e:
+            raise RuntimeError(f"Failed to save labels pkg to {pkg_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.
+        """
+
+        # 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):
@@ -20,10 +21,61 @@ def __init__(self):
             )
         else:
             message = (
-                "<i>Unable to use ffpmeg via imageio. "
+                "<i>Unable to use ffmpeg via imageio. "
                 "<b>AVI</b> file will be encoding using OpenCV.</i>"
             )
 
         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 _get_form_results(self):
+        """Get form results as a dictionary."""
+        return {
+            "fps": self.fps_input.value(),
+            "open_when_done": self.open_when_done.isChecked(),
+        }
+
+    def on_accept(self):
+        """Retrieve the form results and accept the dialog."""
+        self._results = self._get_form_results()
+        self.accept()
+
+    def get_results(self):
+        """Get results as a dictionary."""
+        return self._get_form_results()