singlebehaviorlab 2.2.0__tar.gz → 2.3.1__tar.gz

{singlebehaviorlab-2.2.0/singlebehaviorlab.egg-info → singlebehaviorlab-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: singlebehaviorlab
-Version: 2.2.0
+Version: 2.3.1
 Summary: Semi-automated behavioral video annotation, training, and analysis tool
 Author: Almir Aljovic
 Maintainer: Almir Aljovic

{singlebehaviorlab-2.2.0 → singlebehaviorlab-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "singlebehaviorlab"
-version = "2.2.0"
+version = "2.3.1"
 description = "Semi-automated behavioral video annotation, training, and analysis tool"
 readme = "README.md"
 license = { file = "LICENSE" }

{singlebehaviorlab-2.2.0 → singlebehaviorlab-2.3.1}/singlebehaviorlab/__init__.py

@@ -19,7 +19,7 @@ or videoprism. Each symbol triggers its underlying backend module only on
 first access.
 """
 
-__version__ = "2.2.0"
+__version__ = "2.3.1"
 __author__ = "Almir Aljovic"
 
 # Mapping of public name → (backend module, attribute name).

{singlebehaviorlab-2.2.0 → singlebehaviorlab-2.3.1}/singlebehaviorlab/backend/segmentation.py

@@ -49,6 +49,13 @@ _CHECKPOINT_TO_CONFIG = {
     "sam2.1_hiera_large.pt": "configs/sam2.1/sam2.1_hiera_l.yaml",
 }
 
+_CHECKPOINT_URLS = {
+    "sam2.1_hiera_tiny.pt": "https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_tiny.pt",
+    "sam2.1_hiera_small.pt": "https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_small.pt",
+    "sam2.1_hiera_base_plus.pt": "https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_base_plus.pt",
+    "sam2.1_hiera_large.pt": "https://dl.fbaipublicfiles.com/segment_anything_2/092824/sam2.1_hiera_large.pt",
+}
+
 _CHUNK_SIZE = 200
 
 
@@ -109,10 +116,35 @@ def _resolve_checkpoint(model_name: str) -> tuple[str, str]:
     for candidate in candidates:
         if candidate.exists():
             return str(candidate), config_name
+
+    url = _CHECKPOINT_URLS.get(model_name)
+    if url:
+        dest = checkpoints_root / "checkpoints" / model_name
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        import urllib.request
+        try:
+            from tqdm.auto import tqdm as _tqdm
+        except Exception:
+            _tqdm = None
+        print(f"Downloading {model_name} from {url}")
+        if _tqdm is None:
+            urllib.request.urlretrieve(url, str(dest))
+        else:
+            with urllib.request.urlopen(url) as resp:
+                total = int(resp.headers.get("Content-Length") or 0) or None
+                with _tqdm(total=total, unit="B", unit_scale=True, desc=model_name) as bar:
+                    with open(dest, "wb") as f:
+                        while True:
+                            chunk = resp.read(1024 * 256)
+                            if not chunk:
+                                break
+                            f.write(chunk)
+                            bar.update(len(chunk))
+        if dest.exists() and dest.stat().st_size > 0:
+            return str(dest), config_name
+
     raise FileNotFoundError(
-        f"SAM2 checkpoint '{model_name}' was not found in {checkpoints_root}. "
-        "Launch the GUI once to trigger the automatic download, or place the "
-        "checkpoint file manually in that directory."
+        f"SAM2 checkpoint '{model_name}' could not be downloaded or found in {checkpoints_root}."
     )
 
 

singlebehaviorlab-2.3.1/singlebehaviorlab/backend/segments.py

@@ -0,0 +1,257 @@
+"""Mutable segment list that drives the interactive timeline editor.
+
+Segments are the single source of truth: per-frame label arrays, CSV rows,
+and SVG rectangles are all derived from them. Editing operations enforce
+non-overlap and boundary constraints, and every mutation is tracked by an
+undo/redo stack.
+"""
+
+from __future__ import annotations
+
+import copy
+from dataclasses import dataclass, field
+from typing import Literal, Optional
+
+import numpy as np
+
+__all__ = ["Segment", "SegmentsModel"]
+
+UNDO_LIMIT = 50
+
+
+@dataclass
+class Segment:
+    class_idx: int
+    start: int
+    end: int
+    confidence: float = 1.0
+
+    @property
+    def length(self) -> int:
+        return max(0, self.end - self.start)
+
+    def to_dict(self) -> dict:
+        return {
+            "class": self.class_idx,
+            "start": self.start,
+            "end": self.end,
+            "confidence": self.confidence,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "Segment":
+        return cls(
+            class_idx=int(d["class"]),
+            start=int(d["start"]),
+            end=int(d["end"]),
+            confidence=float(d.get("confidence", 1.0)),
+        )
+
+
+class SegmentsModel:
+    """Ordered, non-overlapping segment list with undo/redo."""
+
+    def __init__(
+        self,
+        segments: list[dict] | list[Segment],
+        classes: list[str],
+        total_frames: int,
+        orig_fps: float = 30.0,
+    ):
+        self.classes = list(classes)
+        self.total_frames = max(0, total_frames)
+        self.orig_fps = float(orig_fps)
+
+        raw = []
+        for s in segments:
+            raw.append(s if isinstance(s, Segment) else Segment.from_dict(s))
+        raw.sort(key=lambda s: s.start)
+        self._segments: list[Segment] = raw
+        self._undo: list[list[Segment]] = []
+        self._redo: list[list[Segment]] = []
+
+    @property
+    def segments(self) -> list[Segment]:
+        return self._segments
+
+    def __len__(self) -> int:
+        return len(self._segments)
+
+    def __getitem__(self, idx: int) -> Segment:
+        return self._segments[idx]
+
+    def _snapshot(self) -> None:
+        self._undo.append(copy.deepcopy(self._segments))
+        if len(self._undo) > UNDO_LIMIT:
+            self._undo.pop(0)
+        self._redo.clear()
+
+    def _clamp(self, val: int) -> int:
+        return max(0, min(self.total_frames, val))
+
+    def _prev_end(self, idx: int) -> int:
+        return self._segments[idx - 1].end if idx > 0 else 0
+
+    def _next_start(self, idx: int) -> int:
+        if idx < len(self._segments) - 1:
+            return self._segments[idx + 1].start
+        return self.total_frames
+
+    # ------------------------------------------------------------------ undo
+
+    @property
+    def can_undo(self) -> bool:
+        return len(self._undo) > 0
+
+    @property
+    def can_redo(self) -> bool:
+        return len(self._redo) > 0
+
+    def undo(self) -> bool:
+        if not self._undo:
+            return False
+        self._redo.append(copy.deepcopy(self._segments))
+        self._segments = self._undo.pop()
+        return True
+
+    def redo(self) -> bool:
+        if not self._redo:
+            return False
+        self._undo.append(copy.deepcopy(self._segments))
+        self._segments = self._redo.pop()
+        return True
+
+    # --------------------------------------------------------------- editing
+
+    def resize(self, idx: int, edge: Literal["left", "right"], delta: int) -> bool:
+        if idx < 0 or idx >= len(self._segments):
+            return False
+        seg = self._segments[idx]
+        self._snapshot()
+
+        if edge == "left":
+            new_start = self._clamp(seg.start + delta)
+            new_start = max(new_start, self._prev_end(idx))
+            if new_start >= seg.end:
+                new_start = seg.end - 1
+            seg.start = new_start
+        else:
+            new_end = self._clamp(seg.end + delta)
+            new_end = min(new_end, self._next_start(idx))
+            if new_end <= seg.start:
+                new_end = seg.start + 1
+            seg.end = new_end
+        return True
+
+    def move(self, idx: int, delta: int) -> bool:
+        if idx < 0 or idx >= len(self._segments):
+            return False
+        seg = self._segments[idx]
+        length = seg.length
+        lo = self._prev_end(idx)
+        hi = self._next_start(idx)
+        if hi - lo < length:
+            return False
+        self._snapshot()
+        new_start = self._clamp(seg.start + delta)
+        new_start = max(new_start, lo)
+        if new_start + length > hi:
+            new_start = hi - length
+        seg.start = new_start
+        seg.end = new_start + length
+        return True
+
+    def reclass(self, idx: int, new_class_idx: int) -> bool:
+        if idx < 0 or idx >= len(self._segments):
+            return False
+        if new_class_idx < 0 or new_class_idx >= len(self.classes):
+            return False
+        self._snapshot()
+        self._segments[idx].class_idx = new_class_idx
+        return True
+
+    def delete(self, idx: int) -> bool:
+        if idx < 0 or idx >= len(self._segments):
+            return False
+        self._snapshot()
+        self._segments.pop(idx)
+        return True
+
+    def split(self, idx: int, at_frame: int) -> bool:
+        if idx < 0 or idx >= len(self._segments):
+            return False
+        seg = self._segments[idx]
+        if at_frame <= seg.start or at_frame >= seg.end:
+            return False
+        self._snapshot()
+        left = Segment(seg.class_idx, seg.start, at_frame, seg.confidence)
+        right = Segment(seg.class_idx, at_frame, seg.end, seg.confidence)
+        self._segments[idx:idx + 1] = [left, right]
+        return True
+
+    def merge_with_next(self, idx: int) -> bool:
+        if idx < 0 or idx >= len(self._segments) - 1:
+            return False
+        self._snapshot()
+        left = self._segments[idx]
+        right = self._segments[idx + 1]
+        left.end = right.end
+        self._segments.pop(idx + 1)
+        return True
+
+    # -------------------------------------------------------- derived outputs
+
+    def to_frame_labels(self) -> np.ndarray:
+        labels = np.full(self.total_frames, -1, dtype=np.int32)
+        for seg in self._segments:
+            labels[seg.start:seg.end] = seg.class_idx
+        return labels
+
+    def to_dicts(self) -> list[dict]:
+        return [s.to_dict() for s in self._segments]
+
+    def to_csv_rows(self) -> list[dict]:
+        rows = []
+        for seg in self._segments:
+            if seg.class_idx < 0 or seg.class_idx >= len(self.classes):
+                name = f"class_{seg.class_idx}"
+            else:
+                name = self.classes[seg.class_idx]
+            fps = max(1e-6, self.orig_fps)
+            rows.append({
+                "Behavior": name,
+                "Start Time (s)": round(seg.start / fps, 4),
+                "End Time (s)": round(seg.end / fps, 4),
+                "Start Frame": seg.start,
+                "End Frame": seg.end,
+                "Duration (s)": round(seg.length / fps, 4),
+                "Confidence": round(seg.confidence, 4),
+            })
+        return rows
+
+    @classmethod
+    def from_frame_labels(
+        cls,
+        labels: np.ndarray,
+        classes: list[str],
+        total_frames: int,
+        orig_fps: float = 30.0,
+        confidences: Optional[np.ndarray] = None,
+    ) -> "SegmentsModel":
+        """Build from a per-frame label array (e.g. argmax output)."""
+        segments: list[Segment] = []
+        if len(labels) == 0:
+            return cls([], classes, total_frames, orig_fps)
+        current_class = int(labels[0])
+        start = 0
+        for i in range(1, len(labels)):
+            if int(labels[i]) != current_class:
+                if current_class >= 0:
+                    conf = float(confidences[start:i].mean()) if confidences is not None else 1.0
+                    segments.append(Segment(current_class, start, i, conf))
+                current_class = int(labels[i])
+                start = i
+        if current_class >= 0:
+            conf = float(confidences[start:].mean()) if confidences is not None else 1.0
+            segments.append(Segment(current_class, start, len(labels), conf))
+        return cls(segments, classes, total_frames, orig_fps)

{singlebehaviorlab-2.2.0 → singlebehaviorlab-2.3.1}/singlebehaviorlab/gui/inference_popups.py

@@ -821,193 +821,6 @@ class FrameSegmentPopupDialog(QDialog):
         add_segment_btn.clicked.connect(add_segment_chunks_to_training)
         training_layout.addWidget(add_segment_btn)
 
-        transition_len_row = QHBoxLayout()
-        transition_len_row.addWidget(QLabel("Transition clip frames:"))
-        transition_len_spin = QSpinBox()
-        transition_len_spin.setRange(2, 64)
-        transition_len_spin.setValue(int(self._widget.clip_length_spin.value()))
-        transition_len_spin.setToolTip("Number of sampled frames to save for this transition clip.")
-        transition_len_row.addWidget(transition_len_spin)
-        transition_len_row.addWidget(QLabel("Ignore ±frames:"))
-        transition_ignore_spin = QSpinBox()
-        transition_ignore_spin.setRange(0, 8)
-        transition_ignore_spin.setValue(1)
-        transition_ignore_spin.setToolTip(
-            "Frames around the exact boundary set to None (ignored during frame loss)."
-        )
-        transition_len_row.addWidget(transition_ignore_spin)
-        training_layout.addLayout(transition_len_row)
-
-        def _safe_label_token(label_text: str) -> str:
-            token = str(label_text or "").strip().replace(" ", "_").replace("/", "_").replace("\\", "_")
-            while "__" in token:
-                token = token.replace("__", "_")
-            return token.strip("_") or "class"
-
-        def _extract_transition_clip(left_seg: dict, right_seg: dict, boundary_name: str):
-            try:
-                left_idx = int(left_seg.get("class", -1))
-                right_idx = int(right_seg.get("class", -1))
-                if not (0 <= left_idx < len(self._widget.classes) and 0 <= right_idx < len(self._widget.classes)):
-                    QMessageBox.warning(self, "Invalid class", "Could not resolve neighboring segment labels.")
-                    return
-
-                left_label = self._widget.classes[left_idx]
-                right_label = self._widget.classes[right_idx]
-                clip_len = int(transition_len_spin.value())
-                if clip_len <= 1:
-                    QMessageBox.warning(self, "Invalid clip length", "Transition clip length must be >= 2.")
-                    return
-                ignore_half = int(max(0, transition_ignore_spin.value()))
-
-                clips_dir = self._widget._get_clips_dir()
-                annotation_manager = AnnotationManager(self._widget._get_annotation_file())
-                annotation_manager.add_class(left_label)
-                annotation_manager.add_class(right_label)
-
-                frame_interval = int(max(1, self._widget._get_saved_frame_interval(self._widget.video_path, orig_fps)))
-                boundary_frame = int((int(left_seg["end"]) + int(right_seg["start"])) // 2)
-                center_idx = clip_len // 2
-                clip_start_vid_frame = max(0, boundary_frame - center_idx * frame_interval)
-
-                cap_local = cv2.VideoCapture(self._widget.video_path)
-                if not cap_local.isOpened():
-                    QMessageBox.warning(self, "Error", "Could not open video file.")
-                    return
-                cap_local.set(cv2.CAP_PROP_POS_FRAMES, clip_start_vid_frame)
-                frames = []
-                sampled_video_frames = []
-                read_ctr = 0
-                while len(frames) < clip_len:
-                    ret, frame = cap_local.read()
-                    if not ret:
-                        break
-                    if read_ctr % frame_interval == 0:
-                        frames.append(frame.copy())
-                        sampled_video_frames.append(int(clip_start_vid_frame + read_ctr))
-                    read_ctr += 1
-                cap_local.release()
-
-                if not frames:
-                    QMessageBox.warning(self, "No frames", "Could not extract transition clip frames.")
-                    return
-
-                if len(frames) < clip_len:
-                    last_frame = frames[-1]
-                    last_idx = sampled_video_frames[-1]
-                    while len(frames) < clip_len:
-                        frames.append(last_frame.copy())
-                        last_idx += frame_interval
-                        sampled_video_frames.append(int(last_idx))
-
-                left_end = int(left_seg["end"]) - ignore_half * frame_interval
-                right_start = int(right_seg["start"]) + ignore_half * frame_interval
-                frame_labels = []
-                for vf in sampled_video_frames:
-                    if vf <= left_end:
-                        frame_labels.append(left_label)
-                    elif vf >= right_start:
-                        frame_labels.append(right_label)
-                    else:
-                        frame_labels.append(None)
-
-                if left_label not in frame_labels:
-                    frame_labels[0] = left_label
-                if right_label not in frame_labels:
-                    frame_labels[-1] = right_label
-
-                non_none = [x for x in frame_labels if x is not None]
-                primary_label = left_label
-                if non_none:
-                    left_count = sum(1 for x in non_none if x == left_label)
-                    right_count = sum(1 for x in non_none if x == right_label)
-                    primary_label = left_label if left_count >= right_count else right_label
-
-                video_basename = self._widget._video_basename()
-                left_tok = _safe_label_token(left_label)
-                right_tok = _safe_label_token(right_label)
-                clip_filename = (
-                    f"{video_basename}_transition_{left_tok}_to_{right_tok}_"
-                    f"frame_{clip_start_vid_frame}_len_{clip_len}.mp4"
-                )
-                clip_path = os.path.join(clips_dir, clip_filename)
-                clip_path = self._widget._unique_clip_path(clip_path)
-
-                target_fps = int(self._widget.target_fps_spin.value())
-                save_clip(frames, clip_path, target_fps)
-                if not os.path.exists(clip_path) or os.path.getsize(clip_path) == 0:
-                    QMessageBox.warning(self, "Save failed", "Failed to save transition clip.")
-                    return
-
-                clip_id = self._widget._clip_path_to_id(clip_path, clips_dir)
-                meta = {
-                    "source_video": os.path.basename(self._widget.video_path),
-                    "source_frame": int(clip_start_vid_frame),
-                    "target_fps": int(target_fps),
-                    "clip_length": int(clip_len),
-                    "added_from_inference_transition": True,
-                    "transition_direction": boundary_name,
-                    "transition_from_label": left_label,
-                    "transition_to_label": right_label,
-                    "transition_boundary_frame": int(boundary_frame),
-                    "transition_ignore_half_frames": int(ignore_half),
-                }
-                used_clip_id = annotation_manager.add_clip(clip_id, primary_label, meta=meta)
-                annotation_manager.set_frame_labels(used_clip_id, frame_labels)
-
-                n_left = sum(1 for x in frame_labels if x == left_label)
-                n_right = sum(1 for x in frame_labels if x == right_label)
-                n_ignored = sum(1 for x in frame_labels if x is None)
-                self._widget.log_text.append(
-                    f"Added transition clip ({boundary_name}): {left_label}->{right_label}, "
-                    f"frames={clip_len}, labels=({n_left}/{n_right}/ignored={n_ignored})"
-                )
-                QMessageBox.information(
-                    self,
-                    "Transition clip added",
-                    f"Saved transition training clip.\n\n"
-                    f"From: {left_label}\n"
-                    f"To: {right_label}\n"
-                    f"Direction: {boundary_name}\n"
-                    f"Clip: {os.path.basename(clip_path)}\n"
-                    f"Frame labels: {n_left} left, {n_right} right, {n_ignored} ignored",
-                )
-            except Exception as e:
-                QMessageBox.critical(self, "Error", f"Failed to add transition clip:\n{str(e)}")
-
-        transition_btn_row = QHBoxLayout()
-        prev_transition_btn = QPushButton("Add prev -> current transition clip")
-        next_transition_btn = QPushButton("Add current -> next transition clip")
-        prev_transition_btn.setStyleSheet("background-color: #4b7bec; color: white; font-weight: bold; padding: 5px;")
-        next_transition_btn.setStyleSheet("background-color: #4b7bec; color: white; font-weight: bold; padding: 5px;")
-
-        has_prev_seg = self._segment_idx is not None and self._segment_idx > 0
-        has_next_seg = self._segment_idx is not None and self._segment_idx < (len(self._widget.aggregated_segments) - 1)
-        prev_transition_btn.setEnabled(has_prev_seg)
-        next_transition_btn.setEnabled(has_next_seg)
-        prev_transition_btn.setToolTip("Create one fixed-length transition clip around the previous->current boundary.")
-        next_transition_btn.setToolTip("Create one fixed-length transition clip around the current->next boundary.")
-
-        def _add_prev_transition():
-            if not has_prev_seg:
-                return
-            prev_seg = self._widget.aggregated_segments[self._segment_idx - 1]
-            curr_seg = self._widget.aggregated_segments[self._segment_idx]
-            _extract_transition_clip(prev_seg, curr_seg, "prev_to_current")
-
-        def _add_next_transition():
-            if not has_next_seg:
-                return
-            curr_seg = self._widget.aggregated_segments[self._segment_idx]
-            next_seg = self._widget.aggregated_segments[self._segment_idx + 1]
-            _extract_transition_clip(curr_seg, next_seg, "current_to_next")
-
-        prev_transition_btn.clicked.connect(_add_prev_transition)
-        next_transition_btn.clicked.connect(_add_next_transition)
-        transition_btn_row.addWidget(prev_transition_btn)
-        transition_btn_row.addWidget(next_transition_btn)
-        training_layout.addLayout(transition_btn_row)
-
         training_group.setLayout(training_layout)
         layout.addWidget(training_group)