slider stuff

loop_labeler_ui.py

@@ -15,7 +15,7 @@ class LoopLabeler(QWidget):
         self.resize(900, 600)
         self.data_dir = Path("data/loops")
         self.shots_dir = Path("data/shots")
-        self.json_files = sorted(self.data_dir.glob("*.json"))
+        self.json_files = sorted(self.data_dir.glob("*.loop.json"))
         self.current_json = None
         self.frames = []
         self.loop_candidates = []
@@ -24,15 +24,21 @@ class LoopLabeler(QWidget):
         self.timer.timeout.connect(self.update_preview)
         self.preview_idx = 0
         self.init_ui()
-        if self.json_files:
-            self.load_json(self.json_files[0])
+        # Load the first unannotated file if available
+        self.load_first_unannotated()
 
     def init_ui(self):
         layout = QVBoxLayout()
         # File selector
         self.file_list = QListWidget()
-        for f in self.json_files:
+        from PyQt5.QtGui import QColor, QBrush
+        for i, f in enumerate(self.json_files):
             self.file_list.addItem(f.name)
+            # Visual indicator for annotated files
+            if self.is_annotated(f):
+                item = self.file_list.item(i)
+                if item:  # Ensure item exists
+                    item.setForeground(QBrush(QColor(0, 120, 0)))  # Dark green text for annotated
         self.file_list.currentRowChanged.connect(self.on_file_selected)
         layout.addWidget(self.file_list)
         # Loop candidate selector
@@ -48,6 +54,16 @@ class LoopLabeler(QWidget):
         # Sliders for start/end
         self.start_slider = QSlider(Qt.Orientation(1))  # Qt.Horizontal is 1
         self.end_slider = QSlider(Qt.Orientation(1))
+        
+        # Configure sliders to prevent jumpy behavior
+        for slider in [self.start_slider, self.end_slider]:
+            slider.setPageStep(1)  # Smaller page step for smoother dragging
+            slider.setTracking(True)  # Enable continuous tracking during drag
+        
+        # Initialize tracking variables for smoother dragging
+        self.last_start = 0
+        self.last_end = 0
+        
         self.start_slider.valueChanged.connect(self.on_slider_changed)
         self.end_slider.valueChanged.connect(self.on_slider_changed)
         layout.addWidget(QLabel("Start index"))
@@ -69,30 +85,102 @@ class LoopLabeler(QWidget):
         layout.addWidget(self.save_btn)
         self.setLayout(layout)
     def revert_to_detected(self):
-        candidate = self.loop_candidates[self.current_candidate]
-        self.start_slider.setValue(candidate["start"])
-        self.end_slider.setValue(candidate["end"])
-        self.loop_checkbox.setChecked(True)
+        # Check if we have valid candidates and index
+        if self.loop_candidates and 0 <= self.current_candidate < len(self.loop_candidates):
+            candidate = self.loop_candidates[self.current_candidate]
+            
+            # Check if candidate has the required fields
+            if "start" in candidate and "end" in candidate:
+                # Get values from candidate
+                start_value = int(candidate["start"])
+                end_value = int(candidate["end"])
+                
+                # Ensure values are within valid range
+                nframes = len(self.frames)
+                start_value = max(0, min(start_value, nframes-1 if nframes > 0 else 0))
+                end_value = max(0, min(end_value, nframes-1 if nframes > 0 else 0))
+                
+                # Block signals temporarily to avoid triggering callbacks
+                self.start_slider.blockSignals(True)
+                self.end_slider.blockSignals(True)
+                
+                # Set the values
+                self.end_slider.setValue(end_value)
+                self.start_slider.setValue(start_value)
+                
+                # Re-enable signals
+                self.start_slider.blockSignals(False)
+                self.end_slider.blockSignals(False)
+                
+                # Update the last known values to match reverted positions
+                self.last_start = start_value
+                self.last_end = end_value
+                
+                # Mark as loop
+                self.loop_checkbox.setChecked(True)
+                
+                # Reset preview
+                self.preview_idx = 0
+                
+                # Manually trigger the slider changed callback to ensure UI updates properly
+                self.on_slider_changed()
+            else:
+                print("Cannot revert: candidate missing start/end fields")
+        else:
+            print("Cannot revert: no valid loop candidate")
+            # Set default values
+            nframes = len(self.frames)
+            self.start_slider.setValue(0)
+            default_end = min(10, nframes-1) if nframes > 1 else 0
+            self.end_slider.setValue(default_end)
+            # Force update
+            self.start_slider.update()
+            self.end_slider.update()
 
     def load_json(self, json_path):
         self.current_json = json_path
-        with open(json_path) as f:
-            self.loop_candidates = json.load(f)
-        self.candidate_spin.setMaximum(len(self.loop_candidates)-1)
+        try:
+            with open(json_path) as f:
+                self.loop_candidates = json.load(f)
+                
+            # Validate loop_candidates is a list
+            if not isinstance(self.loop_candidates, list):
+                print(f"Warning: {json_path} does not contain a list of loop candidates")
+                self.loop_candidates = []
+                
+        except (json.JSONDecodeError, FileNotFoundError, PermissionError) as e:
+            print(f"Error loading JSON file {json_path}: {e}")
+            self.loop_candidates = []
+        
+        # Update candidate spinner
+        max_candidate = max(0, len(self.loop_candidates)-1)
+        self.candidate_spin.setMaximum(max_candidate)
         self.current_candidate = 0
         self.candidate_spin.setValue(0)
+        
         # Find corresponding webp
         stem = json_path.name.split(".")[0]
         webp_path = self.shots_dir / f"{stem}.webp"
         self.frames = []
-        if webp_path.exists():
-            with Image.open(webp_path) as im:
-                try:
-                    while True:
-                        self.frames.append(im.convert("RGB"))
-                        im.seek(im.tell() + 1)
-                except EOFError:
-                    pass
+        
+        try:
+            if webp_path.exists():
+                with Image.open(webp_path) as im:
+                    try:
+                        while True:
+                            self.frames.append(im.convert("RGB"))
+                            im.seek(im.tell() + 1)
+                    except EOFError:
+                        pass
+            else:
+                print(f"Warning: WebP file not found: {webp_path}")
+        except Exception as e:
+            print(f"Error loading WebP file {webp_path}: {e}")
+            
+        # If no frames were loaded, ensure there's at least an empty frame
+        if not self.frames:
+            print(f"No frames found in {webp_path}")
+            
         self.update_candidate()
 
     def on_file_selected(self, idx):
@@ -100,23 +188,62 @@ class LoopLabeler(QWidget):
             self.load_json(self.json_files[idx])
 
     def on_candidate_changed(self, idx):
-        self.current_candidate = idx
-        self.update_candidate()
+        if 0 <= idx < len(self.loop_candidates):
+            self.current_candidate = idx
+            self.update_candidate()
+        else:
+            self.current_candidate = 0
 
     def update_candidate(self):
-        candidate = self.loop_candidates[self.current_candidate]
-        start = candidate["start"]
-        end = candidate["end"]
         nframes = len(self.frames)
         # Set both sliders to cover full range from 0 to N
         self.start_slider.setMinimum(0)
         self.start_slider.setMaximum(nframes-1 if nframes > 0 else 0)
         self.end_slider.setMinimum(0)
         self.end_slider.setMaximum(nframes-1 if nframes > 0 else 0)
-        self.start_slider.setValue(start)
-        self.end_slider.setValue(end)
+        
+        # Block signals temporarily to avoid triggering callbacks multiple times
+        self.start_slider.blockSignals(True)
+        self.end_slider.blockSignals(True)
+        
+        try:
+            # Check if there are loop candidates and if the current index is valid
+            if self.loop_candidates and self.current_candidate < len(self.loop_candidates):
+                candidate = self.loop_candidates[self.current_candidate]
+                # Check if candidate has the required keys
+                if "start" in candidate and "end" in candidate:
+                    start = int(candidate["start"])
+                    end = int(candidate["end"])
+                    # Make sure start/end are within valid range
+                    start = max(0, min(start, nframes-1 if nframes > 0 else 0))
+                    end = max(0, min(end, nframes-1 if nframes > 0 else 0))
+                    
+                    self.start_slider.setValue(start)
+                    self.end_slider.setValue(end)
+            else:
+                # Default values if no candidates or invalid index
+                self.start_slider.setValue(0)
+                default_end = min(10, nframes-1) if nframes > 1 else 0
+                self.end_slider.setValue(default_end)
+        finally:
+            # Always re-enable signals
+            self.start_slider.blockSignals(False)
+            self.end_slider.blockSignals(False)
+        
+        # Force UI update
+        self.start_slider.update()
+        self.end_slider.update()
+            
+        # Reset animation
         self.preview_idx = 0
-        self.timer.start(40)
+        
+        # Update the last known values to match current slider positions
+        self.last_start = self.start_slider.value()
+        self.last_end = self.end_slider.value()
+        
+        # Make sure preview animation is running
+        if not self.timer.isActive():
+            self.timer.start(40)
 
     def on_slider_changed(self):
         start = self.start_slider.value()
@@ -126,14 +253,33 @@ class LoopLabeler(QWidget):
         if end <= start:
             # For preview purposes, we'll adjust temporarily in the update_preview method
             pass
-        self.preview_idx = 0
+        
+        # Only reset animation index when the range actually changes,
+        # not during continuous dragging of a single slider
+        if not hasattr(self, 'last_start') or not hasattr(self, 'last_end') or \
+           self.last_start != start or self.last_end != end:
+            self.preview_idx = 0
+            self.last_start = start
+            self.last_end = end
+        
+        # Don't update the sliders directly during value change events
+        # as this can cause jumping behavior
+        
+        # Make sure preview gets updated immediately
+        if not self.timer.isActive():
+            self.timer.start(40)
 
     def update_preview(self):
         start = self.start_slider.value()
         end = self.end_slider.value()
         
         # Handle case where end ≤ start by showing a single frame or appropriate range
-        if self.frames:
+        if self.frames and len(self.frames) > 0:
+            # Make sure start and end are within valid ranges
+            max_idx = len(self.frames) - 1
+            start = max(0, min(start, max_idx))
+            end = max(0, min(end, max_idx))
+            
             if end <= start:
                 # Show just the start frame when end <= start
                 frame_idx = start
@@ -144,51 +290,120 @@ class LoopLabeler(QWidget):
                 frame_idx = start + (self.preview_idx % (end-start))
                 frame = self.frames[frame_idx]
                 show_progress = True
-                
+        else:
+            # Display an empty/blank preview if no frames
             import numpy as np
+            blank_frame = np.ones((320, 320, 3), dtype=np.uint8) * 200  # Light gray
             import cv2
-            frame_resized = frame.resize((320,320))
-            arr = np.array(frame_resized)
-            # Draw progress indicator line at bottom
-            indicator_height = 2
+            from PIL import Image
+            frame = Image.fromarray(cv2.cvtColor(blank_frame, cv2.COLOR_BGR2RGB))
+            show_progress = False
+        
+        # Process and display the frame (shared code for both cases)    
+        import numpy as np
+        import cv2
+        frame_resized = frame.resize((320,320))
+        arr = np.array(frame_resized)
+        # Draw progress indicator line at bottom
+        indicator_height = 2
+        
+        # Only show progress bar when we have a valid range
+        if show_progress:
+            total = end - start
+            pos = self.preview_idx % total
+            bar_w = int(320 * (pos / max(total-1, 1)))
+        else:
+            # Just show a full bar for single frame
+            bar_w = 320
             
-            # Only show progress bar when we have a valid range
-            if show_progress:
-                total = end - start
-                pos = self.preview_idx % total
-                bar_w = int(320 * (pos / max(total-1, 1)))
-            else:
-                # Just show a full bar for single frame
-                bar_w = 320
-                
-            arr[-indicator_height:, :320] = [220, 220, 220]  # light gray background
-            arr[-indicator_height:, :bar_w] = [100, 100, 255]    # red progress
-            # Convert RGB to BGR for OpenCV, then to QImage
-            arr = cv2.cvtColor(arr, cv2.COLOR_RGB2BGR)
-            h, w, ch = arr.shape
-            bytes_per_line = ch * w
-            from PyQt5.QtGui import QImage
-            qimg = QImage(arr.data, w, h, bytes_per_line, QImage.Format_BGR888)
-            pixmap = QPixmap.fromImage(qimg)
-            self.preview_label.setPixmap(pixmap)
-            self.preview_idx += 1
+        arr[-indicator_height:, :320] = [220, 220, 220]  # light gray background
+        arr[-indicator_height:, :bar_w] = [100, 100, 255]    # red progress
+        # Convert RGB to BGR for OpenCV, then to QImage
+        arr = cv2.cvtColor(arr, cv2.COLOR_RGB2BGR)
+        h, w, ch = arr.shape
+        bytes_per_line = ch * w
+        from PyQt5.QtGui import QImage
+        qimg = QImage(arr.data, w, h, bytes_per_line, QImage.Format_BGR888)
+        pixmap = QPixmap.fromImage(qimg)
+        self.preview_label.setPixmap(pixmap)
+        self.preview_idx += 1
 
     def save_annotation(self):
-        candidate = self.loop_candidates[self.current_candidate]
         start = self.start_slider.value()
         end = self.end_slider.value()
         is_loop = self.loop_checkbox.isChecked()
+        
         # Save to new file (or overwrite)
         if self.current_json is not None:
-            out_path = self.current_json.with_suffix(".hf.json")
-            hf_data = {
-                "loop": bool(is_loop),
-                "best_cut": [start, end]
-            }
-            with open(out_path, "w") as f:
-                json.dump(hf_data, f, indent=2)
+            try:
+                out_path = self.current_json.with_suffix(".hf.json")
+                hf_data = {
+                    "loop": bool(is_loop),
+                    "best_cut": [start, end]
+                }
+                with open(out_path, "w") as f:
+                    json.dump(hf_data, f, indent=2)
+                print(f"Annotation saved to {out_path}")
+                
+                # After saving, load the next unannotated file
+                self.load_next_unannotated()
+            except Exception as e:
+                print(f"Error saving annotation: {e}")
         else:
             print("No JSON file loaded. Cannot save annotation.")
+    
+    def is_annotated(self, json_file):
+        """Check if a JSON file has a corresponding human feedback (.hf.json) file"""
+        hf_file = json_file.with_suffix(".hf.json")
+        return hf_file.exists()
+        
+    def find_first_unannotated(self):
+        """Find the index of the first unannotated JSON file"""
+        for idx, json_file in enumerate(self.json_files):
+            if not self.is_annotated(json_file):
+                return idx
+        # If all files are annotated, return 0
+        return 0 if self.json_files else None
+    
+    def find_next_unannotated(self, current_idx):
+        """Find the index of the next unannotated JSON file after current_idx"""
+        if current_idx is None:
+            return self.find_first_unannotated()
+            
+        # Start from the next file
+        for idx in range(current_idx + 1, len(self.json_files)):
+            if not self.is_annotated(self.json_files[idx]):
+                return idx
+                
+        # If no more unannotated files after current, wrap around to the beginning
+        for idx in range(0, current_idx + 1):
+            if not self.is_annotated(self.json_files[idx]):
+                return idx
+                
+        # If all files are annotated, return the current index
+        return current_idx
+    
+    def load_first_unannotated(self):
+        """Load the first unannotated JSON file in the list"""
+        if not self.json_files:
+            return
+            
+        idx = self.find_first_unannotated()
+        if idx is not None:
+            self.file_list.setCurrentRow(idx)
+            self.load_json(self.json_files[idx])
+    
+    def load_next_unannotated(self):
+        """Load the next unannotated JSON file after the current one"""
+        if not self.json_files or self.current_json is None:
+            return
+            
+        current_idx = self.json_files.index(self.current_json)
+        next_idx = self.find_next_unannotated(current_idx)
+        
+        if next_idx is not None and next_idx != current_idx:
+            self.file_list.setCurrentRow(next_idx)
+            self.load_json(self.json_files[next_idx])
 
 if __name__ == "__main__":
     app = QApplication(sys.argv)