lazylabel-gui 1.1.8__py3-none-any.whl → 1.2.0__py3-none-any.whl

lazylabel/ui/widgets/__init__.py

@@ -3,6 +3,7 @@
 from .adjustments_widget import AdjustmentsWidget
 from .border_crop_widget import BorderCropWidget
 from .channel_threshold_widget import ChannelThresholdWidget
+from .fft_threshold_widget import FFTThresholdWidget
 from .fragment_threshold_widget import FragmentThresholdWidget
 from .model_selection_widget import ModelSelectionWidget
 from .settings_widget import SettingsWidget
@@ -12,6 +13,7 @@ __all__ = [
     "AdjustmentsWidget",
     "BorderCropWidget",
     "ChannelThresholdWidget",
+    "FFTThresholdWidget",
     "FragmentThresholdWidget",
     "ModelSelectionWidget",
     "SettingsWidget",

lazylabel/ui/widgets/fft_threshold_widget.py

@@ -0,0 +1,392 @@
+"""
+FFT Threshold Widget for LazyLabel.
+
+This widget provides FFT-based thresholding for single channel images.
+It includes frequency band thresholding and intensity thresholding.
+Users can double-click to add threshold points for both frequency and intensity processing.
+"""
+
+import numpy as np
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtWidgets import (
+    QCheckBox,
+    QGroupBox,
+    QLabel,
+    QVBoxLayout,
+    QWidget,
+)
+from scipy.fft import fft2, fftshift, ifft2
+
+# Import MultiIndicatorSlider from channel threshold widget
+from .channel_threshold_widget import MultiIndicatorSlider
+
+
+class FFTThresholdSlider(MultiIndicatorSlider):
+    """Custom slider for FFT thresholds that allows removing all indicators."""
+
+    def contextMenuEvent(self, event):
+        """Handle right-click to remove indicator (allows removing all indicators)."""
+        from PyQt6.QtCore import QRect
+
+        slider_rect = self.get_slider_rect()
+
+        # Allow removal of any indicator (no minimum constraint)
+        # Check if right-clicking on an indicator
+        for i, value in enumerate(self.indicators):
+            x = self.value_to_x(value)
+            handle_rect = QRect(
+                x - 6, slider_rect.top() - 3, 12, slider_rect.height() + 6
+            )
+
+            if handle_rect.contains(event.pos()):
+                self.indicators.pop(i)
+                self.valueChanged.emit(self.indicators[:])
+                self.update()
+                return
+
+
+class FFTThresholdWidget(QWidget):
+    """Widget for FFT-based thresholding of single channel images."""
+
+    fft_threshold_changed = pyqtSignal()  # Emitted when FFT threshold changes
+    dragStarted = pyqtSignal()  # Emitted when slider drag starts
+    dragFinished = pyqtSignal()  # Emitted when slider drag finishes
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.current_image_channels = (
+            0  # 0 = no image, 1 = grayscale, 3+ = not supported
+        )
+        self.frequency_thresholds = []  # List of frequency threshold percentages (0-100)
+        self.intensity_thresholds = []  # List of intensity threshold percentages (0-100)
+        self._setup_ui()
+        self._connect_signals()
+
+    def _setup_ui(self):
+        """Setup the UI layout."""
+        group = QGroupBox("FFT Frequency Band Thresholding")
+        layout = QVBoxLayout(group)
+        layout.setSpacing(8)
+
+        # Enable checkbox
+        self.enable_checkbox = QCheckBox("Enable FFT Frequency Thresholding")
+        self.enable_checkbox.setChecked(False)
+        layout.addWidget(self.enable_checkbox)
+
+        # Status label
+        self.status_label = QLabel("Load a single channel (grayscale) image")
+        self.status_label.setStyleSheet(
+            "color: #888; font-size: 9px; font-style: italic;"
+        )
+        layout.addWidget(self.status_label)
+
+        # Frequency threshold slider (percentage-based)
+        freq_label = QLabel("Frequency Thresholds (Double-click to add):")
+        freq_label.setStyleSheet("font-weight: bold; margin-top: 5px;")
+        layout.addWidget(freq_label)
+
+        self.frequency_slider = FFTThresholdSlider(
+            channel_name="Frequency Bands", minimum=0, maximum=100, parent=self
+        )
+        self.frequency_slider.setEnabled(False)
+        self.frequency_slider.setToolTip(
+            "Double-click to add frequency cutoff points. Each frequency band gets mapped to a different intensity level."
+        )
+        layout.addWidget(self.frequency_slider)
+
+        # Intensity threshold slider (percentage-based)
+        intensity_label = QLabel("Intensity Thresholds (Double-click to add):")
+        intensity_label.setStyleSheet("font-weight: bold; margin-top: 10px;")
+        layout.addWidget(intensity_label)
+
+        self.intensity_slider = FFTThresholdSlider(
+            channel_name="Intensity Levels", minimum=0, maximum=100, parent=self
+        )
+        self.intensity_slider.setEnabled(False)
+        self.intensity_slider.setToolTip(
+            "Double-click to add intensity threshold points. Applied after frequency band processing."
+        )
+        layout.addWidget(self.intensity_slider)
+
+        # Instructions
+        instructions = QLabel(
+            "1. Add frequency thresholds to create bands: low freq → dark, high freq → bright.\n"
+            "2. Add intensity thresholds to further process the result with quantization levels."
+        )
+        instructions.setStyleSheet("color: #888; font-size: 9px;")
+        instructions.setWordWrap(True)
+        layout.addWidget(instructions)
+
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.addWidget(group)
+
+    def _connect_signals(self):
+        """Connect internal signals."""
+        # Enable checkbox connection
+        self.enable_checkbox.toggled.connect(self._on_enable_checkbox_toggled)
+
+        # Frequency threshold connections
+        self.frequency_slider.valueChanged.connect(self._on_frequency_slider_changed)
+        self.frequency_slider.dragStarted.connect(self.dragStarted.emit)
+        self.frequency_slider.dragFinished.connect(self.dragFinished.emit)
+
+        # Intensity threshold connections
+        self.intensity_slider.valueChanged.connect(self._on_intensity_slider_changed)
+        self.intensity_slider.dragStarted.connect(self.dragStarted.emit)
+        self.intensity_slider.dragFinished.connect(self.dragFinished.emit)
+
+    def _on_enable_checkbox_toggled(self, checked):
+        """Handle enable checkbox toggle."""
+        # Enable/disable controls based on checkbox state
+        self.frequency_slider.setEnabled(checked)
+        self.intensity_slider.setEnabled(checked)
+
+        # If unchecking, optionally reset the thresholds
+        if not checked:
+            self.frequency_slider.reset()  # Clear frequency threshold indicators
+            self.intensity_slider.reset()  # Clear intensity threshold indicators
+            self.frequency_thresholds = []  # Clear stored thresholds
+            self.intensity_thresholds = []  # Clear stored thresholds
+
+        # Always emit change signal when checkbox is toggled (both check and uncheck)
+        # This ensures the image refreshes to show/remove thresholding
+        self.fft_threshold_changed.emit()
+
+    def _on_frequency_slider_changed(self, indicators):
+        """Handle frequency threshold slider change (receives list of threshold indicators)."""
+        # Store the frequency threshold indicators (percentages 0-100)
+        self.frequency_thresholds = indicators[:]  # Copy the list
+        self._emit_change_if_active()
+
+    def _on_intensity_slider_changed(self, indicators):
+        """Handle intensity threshold slider change (receives list of threshold indicators)."""
+        # Store the intensity threshold indicators (percentages 0-100)
+        self.intensity_thresholds = indicators[:]  # Copy the list
+        self._emit_change_if_active()
+
+    def _emit_change_if_active(self):
+        """Emit change signal if FFT processing is active."""
+        if self.is_active():
+            self.fft_threshold_changed.emit()
+
+    def update_fft_threshold_for_image(self, image_array):
+        """Update widget based on loaded image."""
+        if image_array is None:
+            self.current_image_channels = 0
+            self.status_label.setText("Load a single channel (grayscale) image")
+            self.status_label.setStyleSheet(
+                "color: #888; font-size: 9px; font-style: italic;"
+            )
+            return
+
+        # Determine if image is grayscale (single channel or 3-channel with identical values)
+        if len(image_array.shape) == 2:
+            # True grayscale - supported
+            self.current_image_channels = 1
+            self.status_label.setText("✓ Grayscale image - FFT processing available")
+            self.status_label.setStyleSheet(
+                "color: #4CAF50; font-size: 9px; font-style: italic;"
+            )
+        elif len(image_array.shape) == 3 and image_array.shape[2] == 3:
+            # Check if all three channels are identical (grayscale stored as RGB)
+            r_channel = image_array[:, :, 0]
+            g_channel = image_array[:, :, 1]
+            b_channel = image_array[:, :, 2]
+            if np.array_equal(r_channel, g_channel) and np.array_equal(
+                g_channel, b_channel
+            ):
+                # Grayscale stored as RGB - supported
+                self.current_image_channels = 1
+                self.status_label.setText(
+                    "✓ Grayscale image (RGB format) - FFT processing available"
+                )
+                self.status_label.setStyleSheet(
+                    "color: #4CAF50; font-size: 9px; font-style: italic;"
+                )
+            else:
+                # True multi-channel - not supported
+                self.current_image_channels = 3
+                self.status_label.setText(
+                    "❌ Multi-channel color image - not supported"
+                )
+                self.status_label.setStyleSheet(
+                    "color: #F44336; font-size: 9px; font-style: italic;"
+                )
+        else:
+            # Unknown format
+            self.current_image_channels = 0
+            self.status_label.setText("❌ Unsupported image format")
+            self.status_label.setStyleSheet(
+                "color: #F44336; font-size: 9px; font-style: italic;"
+            )
+
+    def is_active(self):
+        """Check if FFT processing is active (checkbox enabled and image is grayscale)."""
+        return self.enable_checkbox.isChecked() and self.current_image_channels == 1
+
+    def apply_fft_thresholding(self, image_array):
+        """Apply frequency band thresholding to image array and return modified array."""
+        if not self.is_active() or image_array is None:
+            return image_array
+
+        # Handle both 2D grayscale and 3D grayscale (stored as RGB) images
+        if len(image_array.shape) == 2:
+            # True grayscale
+            processing_image = image_array
+            is_3channel = False
+        elif len(image_array.shape) == 3 and image_array.shape[2] == 3:
+            # Check if it's grayscale stored as RGB
+            r_channel = image_array[:, :, 0]
+            g_channel = image_array[:, :, 1]
+            b_channel = image_array[:, :, 2]
+            if np.array_equal(r_channel, g_channel) and np.array_equal(
+                g_channel, b_channel
+            ):
+                # Convert to 2D for processing
+                processing_image = image_array[:, :, 0]
+                is_3channel = True
+            else:
+                return image_array
+        else:
+            return image_array
+
+        try:
+            result_image = self._apply_frequency_band_thresholding(processing_image)
+
+            # Convert back to original format if needed
+            if is_3channel:
+                result = np.stack([result_image, result_image, result_image], axis=2)
+            else:
+                result = result_image
+
+            return result
+
+        except Exception:
+            # If FFT processing fails, return original image
+            return image_array
+
+    def _apply_frequency_band_thresholding(self, image_array):
+        """Apply frequency band thresholding with multiple frequency cutoffs."""
+        # Convert to float for processing
+        image_float = image_array.astype(np.float64)
+        height, width = image_float.shape
+
+        # Apply FFT
+        fft_image = fft2(image_float)
+        fft_shifted = fftshift(fft_image)
+
+        # Create frequency coordinate arrays (normalized 0-1)
+        y_coords, x_coords = np.ogrid[:height, :width]
+        center_y, center_x = height // 2, width // 2
+
+        # Calculate distance from center (frequency magnitude)
+        max_freq = np.sqrt((height / 2) ** 2 + (width / 2) ** 2)
+        freq_distance = (
+            np.sqrt((y_coords - center_y) ** 2 + (x_coords - center_x) ** 2) / max_freq
+        )
+        freq_distance = np.clip(freq_distance, 0, 1)  # Normalize to 0-1
+
+        if not self.frequency_thresholds:
+            # No frequency thresholds - use original FFT
+            result_fft = fft_shifted
+        else:
+            # Create frequency bands based on thresholds
+            sorted_thresholds = sorted(self.frequency_thresholds)
+            freq_thresholds_normalized = [
+                t / 100.0 for t in sorted_thresholds
+            ]  # Convert to 0-1
+
+            # Number of bands = number of thresholds + 1
+            num_bands = len(freq_thresholds_normalized) + 1
+            result_fft = np.zeros_like(fft_shifted, dtype=complex)
+
+            for band_idx in range(num_bands):
+                # Define frequency band
+                if band_idx == 0:
+                    # First band: 0 to first threshold
+                    band_mask = freq_distance <= freq_thresholds_normalized[0]
+                elif band_idx == num_bands - 1:
+                    # Last band: last threshold to 1
+                    band_mask = freq_distance > freq_thresholds_normalized[band_idx - 1]
+                else:
+                    # Middle bands: between two thresholds
+                    band_mask = (
+                        freq_distance > freq_thresholds_normalized[band_idx - 1]
+                    ) & (freq_distance <= freq_thresholds_normalized[band_idx])
+
+                # Band intensity (evenly distributed)
+                band_intensity = (band_idx / (num_bands - 1)) if num_bands > 1 else 1.0
+
+                # Apply band contribution
+                result_fft += fft_shifted * band_mask * band_intensity
+
+        # Inverse FFT
+        filtered_fft_unshifted = fftshift(result_fft)
+        filtered_image = np.real(ifft2(filtered_fft_unshifted))
+
+        # Normalize to 0-255 range
+        filtered_image = filtered_image - np.min(filtered_image)
+        if np.max(filtered_image) > 0:
+            filtered_image = filtered_image / np.max(filtered_image) * 255
+
+        result_image = filtered_image.astype(np.uint8)
+
+        # Apply intensity thresholding if specified
+        if self.intensity_thresholds:
+            result_image = self._apply_intensity_thresholding(result_image)
+
+        return result_image
+
+    def _apply_intensity_thresholding(self, image_array):
+        """Apply intensity thresholding to the image array."""
+        sorted_thresholds = sorted(self.intensity_thresholds)
+
+        # If no thresholds, return original
+        if not sorted_thresholds:
+            return image_array
+
+        # Convert thresholds from percentages to intensity values (0-255)
+        intensity_thresholds = [t * 255 / 100.0 for t in sorted_thresholds]
+
+        # Number of levels = number of thresholds + 1
+        num_levels = len(intensity_thresholds) + 1
+        result_image = np.copy(image_array)
+
+        for level_idx in range(num_levels):
+            # Define intensity range for this level
+            if level_idx == 0:
+                # First level: 0 to first threshold
+                mask = image_array <= intensity_thresholds[0]
+            elif level_idx == num_levels - 1:
+                # Last level: last threshold to 255
+                mask = image_array > intensity_thresholds[level_idx - 1]
+            else:
+                # Middle levels: between two thresholds
+                mask = (image_array > intensity_thresholds[level_idx - 1]) & (
+                    image_array <= intensity_thresholds[level_idx]
+                )
+
+            # Map to quantized level (evenly distributed)
+            level_value = (
+                (level_idx / (num_levels - 1)) * 255 if num_levels > 1 else 255
+            )
+            result_image[mask] = level_value
+
+        return result_image.astype(np.uint8)
+
+    def get_settings(self):
+        """Get current FFT threshold settings."""
+        return {
+            "frequency_thresholds": self.frequency_thresholds,
+            "intensity_thresholds": self.intensity_thresholds,
+            "is_active": self.is_active(),
+        }
+
+    def reset(self):
+        """Reset to default values."""
+        self.frequency_slider.reset()  # Reset the frequency slider
+        self.intensity_slider.reset()  # Reset the intensity slider
+        self.frequency_thresholds = []
+        self.intensity_thresholds = []

{lazylabel_gui-1.1.8.dist-info → lazylabel_gui-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lazylabel-gui
-Version: 1.1.8
+Version: 1.2.0
 Summary: An image segmentation GUI for generating ML ready mask tensors and annotations.
 Author-email: "Deniz N. Cakan" <deniz.n.cakan@gmail.com>
 License: MIT License
@@ -57,7 +57,7 @@ Dynamic: license-file
 
 **AI-Assisted Image Segmentation Made Simple**
 
-LazyLabel combines Meta's Segment Anything Model (SAM) with intuitive editing tools for fast, precise image labeling. Perfect for machine learning datasets, computer vision research, and annotation workflows.
+LazyLabel combines Meta's Segment Anything Model (SAM) with intuitive editing tools for fast, precise image labeling. Perfect for machine learning datasets and computer vision research.
 
 ![LazyLabel Screenshot](https://raw.githubusercontent.com/dnzckn/LazyLabel/main/src/lazylabel/demo_pictures/gui.PNG)
 
@@ -71,67 +71,57 @@ pip install lazylabel-gui
 lazylabel-gui
 ```
 
+### Optional: SAM-2 Support
+For advanced SAM-2 models, install manually:
+```bash
+pip install git+https://github.com/facebookresearch/sam2.git
+```
+*Note: SAM-2 is optional - LazyLabel works with SAM 1.0 models by default*
+
 ### Usage
 1. **Open Folder** → Select your image directory
 2. **Click on image** → AI generates instant masks  
-3. **Fine-tune** → Edit polygons, merge segments, adjust classes
+3. **Fine-tune** → Edit polygons, merge segments
 4. **Export** → Clean `.npz` files ready for ML training
 
 ---
 
 ## ✨ Key Features
 
-### **🧠 AI-Powered Segmentation**
-- **One-click masking** with Meta's SAM model
-- **Smart prompting** via positive/negative points
-- **Fragment filtering** to remove small artifacts
-- **Multiple model support** (VIT-H, VIT-L, VIT-B)
-
-### **🎨 Advanced Editing**
-- **Polygon drawing** with full vertex control
-- **Bounding box** annotation mode
-- **Shape merging** and class assignment
-- **Edit mode** for precision adjustments
-
-### **⚡ Productivity Tools**
-- **Image adjustments** (brightness, contrast, gamma) 
-- **Customizable hotkeys** for all functions
-- **Undo/redo** with full history
-- **Auto-save** and session persistence
-
-### **📊 ML-Ready Outputs**
-- **One-hot encoded** `.npz` format
-- **Clean class separation** with shape `(H, W, Classes)`
-- **Batch processing** support
-- **Existing mask loading** for iterative work
+- **🧠 One-click AI segmentation** with Meta's SAM and SAM2 models
+- **🎨 Manual polygon drawing** with full vertex control
+- **⚡ Smart editing tools** - merge segments, adjust class names, and class order
+- **📊 ML-ready exports** - One-hot encoded `.npz` format and `.json` for YOLO format
+- **🔧 Image enhancement** - brightness, contrast, gamma adjustment
+- **🔍 Image viewer** - zoom, pan, brightness, contrast, and gamma adjustment
+- **✂️ Edge cropping** - define custom crop areas to focus on specific regions
+- **🔄 Undo/Redo** - full history of all actions
+- **💾 Auto-saving** - Automatic saving of your labels when navigating between images
+- **🎛️ Advanced filtering** - FFT thresholding and color channel thresholding
+- **⌨️ Customizable hotkeys** for all functions
 
 ---
 
-## ⌨️ Essential Controls
-
-| Mode | Key | Action |
-|------|-----|--------|
-| **AI Segmentation** | `1` | Point mode for SAM |
-| | `Left Click` | Add positive point |
-| | `Right Click` | Add negative point |
-| | `Space` | Save segment |
-| **Manual Drawing** | `2` | Polygon mode |
-| | `Left Click` | Add vertex |
-| | `Enter` | Close polygon |
-| **Editing** | `E` | Selection mode |
-| | `R` | Edit selected shapes |
-| | `M` | Merge selected segments |
-| **Navigation** | `Q` | Pan mode |
-| | `W/A/S/D` | Pan image |
-| | `Scroll` | Zoom in/out |
-
-**💡 All hotkeys are customizable** - Click "Hotkeys" button to personalize shortcuts
+## ⌨️ Essential Hotkeys
+
+| Action | Key | Description |
+|--------|-----|-------------|
+| **AI Mode** | `1` | Point-click segmentation |
+| **Draw Mode** | `2` | Manual polygon drawing |
+| **Edit Mode** | `E` | Select and modify shapes |
+| **Save Segment** | `Space` | Confirm current mask |
+| **Merge** | `M` | Combine selected segments |
+| **Pan** | `Q` + drag | Navigate large images |
+| **Positive Point** | `Left Click` | Add to segment |
+| **Negative Point** | `Right Click` | Remove from segment |
+
+💡 **All hotkeys customizable** - Click "Hotkeys" button to personalize
 
 ---
 
 ## 📦 Output Format
 
-LazyLabel exports clean, ML-ready data:
+Perfect for ML training - clean, structured data:
 
 ```python
 import numpy as np
@@ -141,41 +131,24 @@ data = np.load('your_image.npz')
 mask = data['mask']  # Shape: (height, width, num_classes)
 
 # Each channel is a binary mask for one class
-class_0_mask = mask[:, :, 0]  # Binary mask for class 0
-class_1_mask = mask[:, :, 1]  # Binary mask for class 1
-# ... and so on
+class_0_mask = mask[:, :, 0]  # Background
+class_1_mask = mask[:, :, 1]  # Object type 1
+class_2_mask = mask[:, :, 2]  # Object type 2
 ```
 
-**Perfect for:**
-- Semantic segmentation training
-- Instance segmentation datasets  
+
+**Ideal for:**
+- Semantic segmentation datasets
+- Instance segmentation training
 - Computer vision research
 - Automated annotation pipelines
 
 ---
 
-## 🛠️ Advanced Features
-
-### **Image Enhancement**
-- **Brightness/Contrast** adjustment sliders
-- **Gamma correction** for better visibility
-- **Live preview** of adjustments
-- **SAM integration** with adjusted images
-
-### **Smart Filtering**
-- **Fragment threshold** removes small segments
-- **Size-based filtering** (0-100% of largest segment)
-- **Quality control** for clean annotations
-
-### **Professional Workflow**
-- **Class management** with custom aliases
-- **Segment organization** with sortable tables
-- **Batch export** for large datasets
-- **Model switching** without restart
+## 🛠️ Development
 
----
-
-## 🏗️ Development
+**Requirements:** Python 3.10+
+**2.5GB** disk space for SAM model (auto-downloaded)
 
 ### Installation from Source
 ```bash
@@ -185,38 +158,26 @@ pip install -e .
 lazylabel-gui
 ```
 
-### Code Quality & Testing
+### Testing & Quality
 ```bash
-# Linting & formatting
-ruff check . && ruff format .
-
-# Run tests with coverage
+# Run full test suite
 python -m pytest --cov=lazylabel --cov-report=html
 
-# All tests pass with 60%+ coverage
+# Code formatting & linting
+ruff check . && ruff format .
 ```
 
 ### Architecture
-- **Modular design** with clean separation of concerns
-- **Signal-based communication** between components  
+- **Modular design** with clean component separation
+- **Signal-based communication** between UI elements
 - **Extensible model system** for new SAM variants
-- **Comprehensive test suite** with 95% speed optimization
-
----
-
-## 📋 Requirements
-
-- **Python 3.10+**
-- **OpenCV** for image processing
-- **PyQt6** for GUI
-- **NumPy** for data handling
-- **2.5GB** disk space for SAM model (auto-downloaded)
+- **Comprehensive test suite** (150+ tests, 60%+ coverage)
 
 ---
 
 ## 🤝 Contributing
 
-LazyLabel welcomes contributions! Check out our:
+LazyLabel welcomes contributions! Check out:
 - [Architecture Guide](src/lazylabel/ARCHITECTURE.md) for technical details
 - [Hotkey System](src/lazylabel/HOTKEY_FEATURE.md) for customization
 - Issues page for feature requests and bug reports
@@ -225,9 +186,8 @@ LazyLabel welcomes contributions! Check out our:
 
 ## 🙏 Acknowledgments
 
-LazyLabel was inspired by and builds upon the excellent work of:
-- [LabelMe](https://github.com/wkentaro/labelme) - The pioneering open-source image annotation tool
-- [Segment-Anything-UI](https://github.com/branislavhesko/segment-anything-ui) - Early SAM integration concepts
+- [LabelMe](https://github.com/wkentaro/labelme)
+- [Segment-Anything-UI](https://github.com/branislavhesko/segment-anything-ui)
 
 ---