whatever

loop_labeler_ui.py

@@ -3,10 +3,11 @@ import json
 from pathlib import Path
 from PIL import Image, ImageQt
 from PyQt5.QtWidgets import (
-    QApplication, QWidget, QLabel, QPushButton, QSlider, QHBoxLayout, QVBoxLayout, QFileDialog, QListWidget, QSpinBox
+    QApplication, QWidget, QLabel, QPushButton, QSlider, QHBoxLayout, QVBoxLayout, QFileDialog, QListWidget, QSpinBox,
+    QCheckBox
 )
 from PyQt5.QtCore import Qt, QTimer
-from PyQt5.QtGui import QPixmap
+from PyQt5.QtGui import QPixmap, QColor, QBrush, QImage
 
 class LoopLabeler(QWidget):
     def __init__(self):
@@ -35,7 +36,6 @@ class LoopLabeler(QWidget):
         layout = QVBoxLayout()
         # File selector
         self.file_list = QListWidget()
-        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
@@ -55,37 +55,35 @@ class LoopLabeler(QWidget):
         self.preview_label = QLabel()
         self.preview_label.setFixedSize(320, 320)
         layout.addWidget(self.preview_label)
-        # Sliders for start/end
-        self.start_slider = QSlider(Qt.Orientation(1))  # Qt.Horizontal is 1
-        self.end_slider = QSlider(Qt.Orientation(1))
+        # Custom number input fields instead of sliders
+        # Using QSpinBox already imported at the top of the file
         
-        # Configure sliders for better 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
-            slider.setSingleStep(1)  # Set smaller step size for keyboard navigation
+        # Create layout for start controls with label and spinbox
+        start_layout = QHBoxLayout()
+        start_layout.addWidget(QLabel("Start index"))
+        self.start_spin = QSpinBox()
+        self.start_spin.setMinimum(0)
+        self.start_spin.setMaximum(9999)  # Will be updated with actual frame count
+        start_layout.addWidget(self.start_spin)
+        layout.addLayout(start_layout)
         
-        # Values to track current positions (initialized to avoid reference errors)
-        self.current_start = 0
-        self.current_end = 0
-        self.is_dragging = False
+        # Create layout for end controls with label and spinbox
+        end_layout = QHBoxLayout()
+        end_layout.addWidget(QLabel("End index"))
+        self.end_spin = QSpinBox()
+        self.end_spin.setMinimum(0)
+        self.end_spin.setMaximum(9999)  # Will be updated with actual frame count
+        end_layout.addWidget(self.end_spin)
+        layout.addLayout(end_layout)
         
-        # Use sliderPressed/Released to detect dragging state
-        self.start_slider.sliderPressed.connect(lambda: self.on_slider_drag_started('start'))
-        self.start_slider.sliderReleased.connect(self.on_slider_drag_ended)
-        self.end_slider.sliderPressed.connect(lambda: self.on_slider_drag_started('end'))
-        self.end_slider.sliderReleased.connect(self.on_slider_drag_ended)
+        # Connect spinbox value changed signals
+        self.start_spin.valueChanged.connect(self.on_range_changed)
+        self.end_spin.valueChanged.connect(self.on_range_changed)
         
-        # Connect value changed signals
-        self.start_slider.valueChanged.connect(lambda v: self.on_slider_value_changed('start', v))
-        self.end_slider.valueChanged.connect(lambda v: self.on_slider_value_changed('end', v))
-        
-        layout.addWidget(QLabel("Start index"))
-        layout.addWidget(self.start_slider)
-        layout.addWidget(QLabel("End index"))
-        layout.addWidget(self.end_slider)
+        # Keep track of current values
+        self.current_start = 0
+        self.current_end = 0
         # Loop checkbox
-        from PyQt5.QtWidgets import QCheckBox
         self.loop_checkbox = QCheckBox("Is loop?")
         self.loop_checkbox.setChecked(True)
         layout.addWidget(self.loop_checkbox)
@@ -115,20 +113,20 @@ class LoopLabeler(QWidget):
                 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)
+                self.start_spin.blockSignals(True)
+                self.end_spin.blockSignals(True)
                 
                 # Set the values
-                self.end_slider.setValue(end_value)
-                self.start_slider.setValue(start_value)
+                self.end_spin.setValue(end_value)
+                self.start_spin.setValue(start_value)
                 
                 # Update our tracking variables
                 self.current_start = start_value
                 self.current_end = end_value
                 
                 # Re-enable signals
-                self.start_slider.blockSignals(False)
-                self.end_slider.blockSignals(False)
+                self.start_spin.blockSignals(False)
+                self.end_spin.blockSignals(False)
                 
                 # Mark as loop
                 self.loop_checkbox.setChecked(True)
@@ -211,15 +209,13 @@ class LoopLabeler(QWidget):
 
     def update_candidate(self):
         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)
+        # Set both spin boxes to cover full range from 0 to N
+        self.start_spin.setMaximum(nframes-1 if nframes > 0 else 0)
+        self.end_spin.setMaximum(nframes-1 if nframes > 0 else 0)
         
         # Block signals temporarily to avoid triggering callbacks multiple times
-        self.start_slider.blockSignals(True)
-        self.end_slider.blockSignals(True)
+        self.start_spin.blockSignals(True)
+        self.end_spin.blockSignals(True)
         
         try:
             # Check if there are loop candidates and if the current index is valid
@@ -233,9 +229,9 @@ class LoopLabeler(QWidget):
                     start = max(0, min(start, nframes-1 if nframes > 0 else 0))
                     end = max(0, min(end, nframes-1 if nframes > 0 else 0))
                     
-                    # Set sliders and update our tracking variables
-                    self.start_slider.setValue(start)
-                    self.end_slider.setValue(end)
+                    # Set spin box values and update our tracking variables
+                    self.start_spin.setValue(start)
+                    self.end_spin.setValue(end)
                     self.current_start = start
                     self.current_end = end
             else:
@@ -243,15 +239,15 @@ class LoopLabeler(QWidget):
                 start = 0
                 default_end = min(10, nframes-1) if nframes > 1 else 0
                 
-                # Set sliders and update our tracking variables
-                self.start_slider.setValue(start)
-                self.end_slider.setValue(default_end)
+                # Set spin box values and update our tracking variables
+                self.start_spin.setValue(start)
+                self.end_spin.setValue(default_end)
                 self.current_start = start
                 self.current_end = default_end
         finally:
             # Always re-enable signals
-            self.start_slider.blockSignals(False)
-            self.end_slider.blockSignals(False)
+            self.start_spin.blockSignals(False)
+            self.end_spin.blockSignals(False)
             
         # Reset animation
         self.preview_idx = 0
@@ -260,39 +256,21 @@ class LoopLabeler(QWidget):
         if not self.timer.isActive():
             self.timer.start(40)
 
-    def on_slider_drag_started(self, slider_type):
-        """Called when user starts dragging a slider"""
-        self.is_dragging = True
-        self.dragging_slider = slider_type
-        # Store initial values at the start of drag
-        self.drag_start_value = self.start_slider.value()
-        self.drag_end_value = self.end_slider.value()
-    
-    def on_slider_drag_ended(self):
-        """Called when user releases a slider after dragging"""
-        self.is_dragging = False
-        # No need to update again, the valueChanged events already did it
+    def on_range_changed(self):
+        """Called when either spinbox value changes"""
+        # Update our cached values
+        self.current_start = self.start_spin.value()
+        self.current_end = self.end_spin.value()
         
-        # Reset preview index when drag is complete for a smooth preview
+        # Reset animation index to give a smooth preview after changing range
         self.preview_idx = 0
         
         # Make sure preview is running
         if not self.timer.isActive():
             self.timer.start(40)
-    
-    def on_slider_value_changed(self, slider_type, value):
-        """Called when slider value changes (drag, programmatic, etc.)"""
-        # Update our cached values
-        if slider_type == 'start':
-            self.current_start = value
-        else:  # 'end'
-            self.current_end = value
-        
-        # Update the preview - but don't reset animation during continuous drag
-        if not self.timer.isActive():
-            self.timer.start(40)
 
     def update_preview(self):
+        # Get current values directly from spinboxes to ensure latest values
         start = self.current_start
         end = self.current_end
         
@@ -310,8 +288,10 @@ class LoopLabeler(QWidget):
                 show_progress = False
             else:
                 # Normal case: show animation between start and end
-                frame_idx = start + (self.preview_idx % (end-start+1))
-                if frame_idx > max_idx:
+                # The +1 is because we want to include both start and end frames
+                range_size = end - start + 1
+                frame_idx = start + (self.preview_idx % range_size)
+                if frame_idx > max_idx:  # Safety check
                     frame_idx = max_idx
                 frame = self.frames[frame_idx]
                 show_progress = True
@@ -329,12 +309,25 @@ class LoopLabeler(QWidget):
         import cv2
         frame_resized = frame.resize((320,320))
         arr = np.array(frame_resized)
+        
+        # Draw current frame number overlay
+        if self.frames and len(self.frames) > 0:
+            cv2.putText(
+                arr, 
+                f"Frame: {frame_idx}", 
+                (10, 30),  # Position (x, y)
+                cv2.FONT_HERSHEY_SIMPLEX,  # Font
+                0.7,  # Scale
+                (255, 255, 255),  # Color (white)
+                2  # Thickness
+            )
+        
         # 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
+            total = end - start + 1  # +1 to include both start and end frames
             pos = self.preview_idx % total
             bar_w = int(320 * (pos / max(total-1, 1)))
         else:
@@ -347,7 +340,6 @@ class LoopLabeler(QWidget):
         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)