From 5648793a2ad1aa17d7fdd8acdfda09b393ff7999 Mon Sep 17 00:00:00 2001 From: Cruiz102 Date: Fri, 20 Jun 2025 20:35:36 -0400 Subject: [PATCH 1/8] gpt goes brrr data engine [first generation lol] --- data_engine/Makefile | 100 +++++ data_engine/README.md | 209 +++++++++ data_engine/config.py | 330 ++++++++++++++ data_engine/example.py | 208 +++++++++ data_engine/main.py | 849 +++++++++++++++++++++++++++++++++++ data_engine/requirements.txt | 8 + data_engine/run.py | 100 +++++ data_engine/sam_processor.py | 510 +++++++++++++++++++++ data_engine/setup.py | 136 ++++++ data_engine/utils.py | 368 +++++++++++++++ 10 files changed, 2818 insertions(+) create mode 100644 data_engine/Makefile create mode 100644 data_engine/README.md create mode 100644 data_engine/config.py create mode 100644 data_engine/example.py create mode 100644 data_engine/main.py create mode 100644 data_engine/requirements.txt create mode 100644 data_engine/run.py create mode 100644 data_engine/sam_processor.py create mode 100644 data_engine/setup.py create mode 100644 data_engine/utils.py diff --git a/data_engine/Makefile b/data_engine/Makefile new file mode 100644 index 0000000..84224e9 --- /dev/null +++ b/data_engine/Makefile @@ -0,0 +1,100 @@ +# Makefile for SAM2 Data Engine + +.PHONY: install setup run clean test help + +# Default Python interpreter +PYTHON := python3 + +# Virtual environment name +VENV := venv + +help: ## Show this help message + @echo "SAM2 Data Engine - Available commands:" + @echo + @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf " \033[36m%-15s\033[0m %s\n", $$1, $$2}' + +install: ## Install requirements + $(PYTHON) -m pip install -r requirements.txt + +setup: ## Run full setup (install + download models) + $(PYTHON) setup.py + +run: ## Run the data engine application + $(PYTHON) run.py + +test: ## Run example/test script + $(PYTHON) example.py + +clean: ## Clean cache and temporary files + find . -type d -name "__pycache__" -exec rm -rf {} + + find . -type f -name "*.pyc" -delete + find . -type f -name "*.pyo" -delete + rm -rf test_output/ + rm -rf test_config/ + +venv: ## Create virtual environment + $(PYTHON) -m venv $(VENV) + @echo "Activate with: source $(VENV)/bin/activate" + +venv-install: venv ## Create venv and install requirements + $(VENV)/bin/pip install -r requirements.txt + +venv-run: ## Run application in virtual environment + $(VENV)/bin/python run.py + +dev-install: ## Install development dependencies + $(PYTHON) -m pip install -r requirements.txt + $(PYTHON) -m pip install black flake8 mypy + +format: ## Format code with black + black *.py + +lint: ## Lint code with flake8 + flake8 *.py + +type-check: ## Type check with mypy + mypy *.py --ignore-missing-imports + +check: format lint type-check ## Run all code quality checks + +# Docker commands (if needed) +docker-build: ## Build Docker image + docker build -t sam2-data-engine . + +docker-run: ## Run in Docker container + docker run -it --rm -v $(PWD):/app sam2-data-engine + +# Documentation +docs: ## Generate documentation + @echo "Documentation available in README.md" + @echo "For detailed usage, see: python example.py" + +# System info +info: ## Show system information + @echo "Python version:" + @$(PYTHON) --version + @echo + @echo "Pip packages:" + @$(PYTHON) -m pip list | grep -E "(torch|opencv|PySide6|ultralytics|numpy|Pillow)" + @echo + @echo "CUDA availability:" + @$(PYTHON) -c "import torch; print('CUDA available:', torch.cuda.is_available())" 2>/dev/null || echo "PyTorch not installed" + +# Quick start +quickstart: ## Quick start guide + @echo "SAM2 Data Engine - Quick Start" + @echo "==============================" + @echo + @echo "1. Install dependencies:" + @echo " make install" + @echo + @echo "2. Run setup (download models):" + @echo " make setup" + @echo + @echo "3. Launch application:" + @echo " make run" + @echo + @echo "4. For testing without GUI:" + @echo " make test" + @echo + @echo "For more commands: make help" diff --git a/data_engine/README.md b/data_engine/README.md new file mode 100644 index 0000000..092d3bc --- /dev/null +++ b/data_engine/README.md @@ -0,0 +1,209 @@ +# SAM2 Data Engine - YOLO Dataset Generator + +An automatic data engine GUI application that uses visual prompts to interact with SAM2 (Segment Anything Model 2) for generating YOLO training datasets with automatic video segmentation. + +## Features + +- **Interactive GUI**: Built with PySide6 for modern and intuitive user experience +- **SAM2 Integration**: Uses Ultralytics SAM2 for automatic segmentation +- **Video Navigation**: Move back and forth through video frames +- **Point-based Prompting**: Add positive/negative points for precise segmentation +- **Automatic Propagation**: Forward and backward mask propagation across frames +- **Smart Caching**: Cache frames, masks, and SAM2 features for faster processing +- **YOLO Export**: Export annotations in YOLO dataset format +- **Object Classification**: Assign class names to segmented objects +- **Real-time Visualization**: See segmentation results with overlay masks + +## Requirements + +- Python 3.8+ +- PySide6 +- OpenCV +- NumPy +- PyTorch +- Ultralytics (for SAM2) +- Pillow + +## Installation + +1. **Clone or navigate to the data_engine directory**: +```bash +cd /path/to/hydrus-software-stack/data_engine +``` + +2. **Install dependencies**: +```bash +pip install -r requirements.txt +``` + +3. **Run setup script** (optional - downloads SAM2 models): +```bash +python setup.py +``` + +4. **Launch the application**: +```bash +python main.py +``` + +## Usage + +### 1. Load Video +- Click "Load Video" to select a video file +- Supported formats: MP4, AVI, MOV, MKV, WMV +- Set output directory for caching and exports + +### 2. Navigate Frames +- Use the slider or spinbox to navigate between frames +- Use "◀ Prev" and "Next ▶" buttons for frame-by-frame navigation +- Frames are automatically cached for faster access + +### 3. Add Object Classes +- In the right panel, add class names for your objects +- Each class gets a unique ID automatically +- Select a class before segmenting objects + +### 4. Segment Objects +- **Add Points**: Click on the frame to add positive (green) or negative (red) points +- **Positive Points**: Click inside the object you want to segment +- **Negative Points**: Click outside the object or on background +- **Segment**: Click "Segment Object" to run SAM2 segmentation +- **Clear Points**: Remove all points and start over + +### 5. Propagate Masks +- After segmenting an object, use propagation to track it across frames +- **Forward Propagation**: Tracks object in subsequent frames +- **Backward Propagation**: Tracks object in previous frames + +### 6. Export Dataset +- Click "Export YOLO Dataset" to save annotations +- Creates folder structure: `images/`, `labels/`, `classes.txt`, `dataset.yaml` +- Annotations are saved in YOLO segmentation format + +## Directory Structure + +``` +data_engine/ +├── main.py # Main GUI application +├── sam_processor.py # SAM2 integration module +├── utils.py # Utility functions +├── setup.py # Setup script +├── requirements.txt # Python dependencies +├── README.md # This file +├── cache/ # Cached data +│ ├── frames/ # Cached video frames +│ ├── masks/ # Cached segmentation masks +│ └── features/ # Cached SAM2 features +├── projects/ # Project configurations +└── exports/ # Exported datasets +``` + +## Output Format + +The tool exports datasets in YOLO format: + +### Dataset Structure +``` +yolo_dataset/ +├── images/ # Training images +│ ├── frame_000001.jpg +│ ├── frame_000002.jpg +│ └── ... +├── labels/ # Segmentation labels +│ ├── frame_000001.txt +│ ├── frame_000002.txt +│ └── ... +├── classes.txt # Class names +└── dataset.yaml # YOLO configuration +``` + +### Label Format +Each `.txt` file contains one line per object: +``` +class_id x1 y1 x2 y2 x3 y3 ... xn yn +``` +Where coordinates are normalized (0-1) polygon points. + +## SAM2 Models + +The application supports different SAM2 model sizes: +- `sam2_s.pt` - Small (fastest) +- `sam2_b.pt` - Base (balanced) +- `sam2_l.pt` - Large (most accurate) + +Models are automatically downloaded on first use. + +## Performance Tips + +1. **Use GPU**: Ensure CUDA is available for faster inference +2. **Cache Features**: Enable feature caching for repeated processing +3. **Optimize Points**: Use minimal points for faster segmentation +4. **Batch Processing**: Process multiple frames at once when possible + +## Troubleshooting + +### Common Issues + +1. **Model Loading Error**: + - Ensure internet connection for model download + - Check CUDA/PyTorch compatibility + - Try different model sizes + +2. **Memory Issues**: + - Use smaller SAM2 model (sam2_s.pt) + - Reduce video resolution + - Clear cache regularly + +3. **Slow Performance**: + - Enable GPU acceleration + - Use feature caching + - Process frames in batches + +### System Requirements + +- **Minimum**: 8GB RAM, CPU-only +- **Recommended**: 16GB+ RAM, NVIDIA GPU with 6GB+ VRAM +- **For Large Videos**: 32GB+ RAM, High-end GPU + +## Advanced Features + +### Custom Prompting +- Combine point and box prompts for complex objects +- Use multiple positive/negative points for precision +- Adjust SAM2 parameters for different object types + +### Batch Processing +- Process multiple videos sequentially +- Export datasets in different formats +- Automated quality control and validation + +### Integration +- Export to other annotation formats (COCO, Pascal VOC) +- Integration with training pipelines +- Custom post-processing workflows + +## Contributing + +This tool is part of the Hydrus Software Stack. For contributions: + +1. Follow the existing code structure +2. Add tests for new features +3. Update documentation +4. Ensure compatibility with SAM2 updates + +## License + +See the main Hydrus Software Stack license for details. + +## References + +- [Ultralytics SAM2 Documentation](https://docs.ultralytics.com/models/sam-2/) +- [Segment Anything Model 2](https://github.com/facebookresearch/segment-anything-2) +- [YOLO Format Specification](https://docs.ultralytics.com/datasets/segment/) + +## Support + +For issues and questions: +1. Check the troubleshooting section +2. Review SAM2 documentation +3. Open an issue in the main repository diff --git a/data_engine/config.py b/data_engine/config.py new file mode 100644 index 0000000..b4e2940 --- /dev/null +++ b/data_engine/config.py @@ -0,0 +1,330 @@ +#!/usr/bin/env python3 +""" +Configuration management for the Data Engine +""" + +import json +import os +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import Any, Dict, Optional + + +@dataclass +class SAMConfig: + """SAM2 model configuration""" + + model_name: str = "sam2_b.pt" + device: str = "auto" + multimask_output: bool = False + cache_features: bool = True + batch_size: int = 1 + + +@dataclass +class UIConfig: + """UI configuration""" + + window_width: int = 1400 + window_height: int = 900 + frame_cache_size: int = 100 + auto_save_interval: int = 300 # seconds + default_point_size: int = 5 + overlay_alpha: float = 0.5 + + +@dataclass +class ExportConfig: + """Export configuration""" + + export_format: str = "yolo" # yolo, coco, voc + image_format: str = "jpg" + compression_quality: int = 95 + include_empty_frames: bool = False + validate_annotations: bool = True + + +@dataclass +class CacheConfig: + """Cache configuration""" + + max_cache_size_gb: float = 5.0 + auto_cleanup: bool = True + cleanup_interval_hours: int = 24 + keep_recent_projects: int = 5 + + +@dataclass +class DataEngineConfig: + """Main configuration class""" + + sam: SAMConfig + ui: UIConfig + export: ExportConfig + cache: CacheConfig + project_name: str = "untitled" + last_video_path: str = "" + last_output_dir: str = "" + classes: Dict[int, str] = None + + def __post_init__(self): + if self.classes is None: + self.classes = {} + + +class ConfigManager: + """Configuration manager for the Data Engine""" + + def __init__(self, config_dir: str = None): + if config_dir is None: + config_dir = Path.home() / ".data_engine" + + self.config_dir = Path(config_dir) + self.config_dir.mkdir(exist_ok=True) + + self.config_file = self.config_dir / "config.json" + self.projects_dir = self.config_dir / "projects" + self.projects_dir.mkdir(exist_ok=True) + + self._config = self._load_config() + + def _load_config(self) -> DataEngineConfig: + """Load configuration from file""" + if self.config_file.exists(): + try: + with open(self.config_file, "r") as f: + data = json.load(f) + + # Convert nested dictionaries back to dataclasses + sam_config = SAMConfig(**data.get("sam", {})) + ui_config = UIConfig(**data.get("ui", {})) + export_config = ExportConfig(**data.get("export", {})) + cache_config = CacheConfig(**data.get("cache", {})) + + return DataEngineConfig( + sam=sam_config, + ui=ui_config, + export=export_config, + cache=cache_config, + project_name=data.get("project_name", "untitled"), + last_video_path=data.get("last_video_path", ""), + last_output_dir=data.get("last_output_dir", ""), + classes=data.get("classes", {}), + ) + except Exception as e: + print(f"Error loading config: {e}, using defaults") + + # Return default configuration + return DataEngineConfig( + sam=SAMConfig(), ui=UIConfig(), export=ExportConfig(), cache=CacheConfig() + ) + + def save_config(self): + """Save configuration to file""" + try: + # Convert dataclasses to dictionaries + config_dict = { + "sam": asdict(self._config.sam), + "ui": asdict(self._config.ui), + "export": asdict(self._config.export), + "cache": asdict(self._config.cache), + "project_name": self._config.project_name, + "last_video_path": self._config.last_video_path, + "last_output_dir": self._config.last_output_dir, + "classes": self._config.classes, + } + + with open(self.config_file, "w") as f: + json.dump(config_dict, f, indent=2) + + except Exception as e: + print(f"Error saving config: {e}") + + @property + def config(self) -> DataEngineConfig: + """Get current configuration""" + return self._config + + def update_sam_config(self, **kwargs): + """Update SAM configuration""" + for key, value in kwargs.items(): + if hasattr(self._config.sam, key): + setattr(self._config.sam, key, value) + self.save_config() + + def update_ui_config(self, **kwargs): + """Update UI configuration""" + for key, value in kwargs.items(): + if hasattr(self._config.ui, key): + setattr(self._config.ui, key, value) + self.save_config() + + def update_export_config(self, **kwargs): + """Update export configuration""" + for key, value in kwargs.items(): + if hasattr(self._config.export, key): + setattr(self._config.export, key, value) + self.save_config() + + def update_cache_config(self, **kwargs): + """Update cache configuration""" + for key, value in kwargs.items(): + if hasattr(self._config.cache, key): + setattr(self._config.cache, key, value) + self.save_config() + + def set_last_paths(self, video_path: str = None, output_dir: str = None): + """Update last used paths""" + if video_path: + self._config.last_video_path = video_path + if output_dir: + self._config.last_output_dir = output_dir + self.save_config() + + def save_project(self, project_name: str, project_data: Dict[str, Any]): + """Save project data""" + project_file = self.projects_dir / f"{project_name}.json" + try: + with open(project_file, "w") as f: + json.dump(project_data, f, indent=2) + except Exception as e: + print(f"Error saving project: {e}") + + def load_project(self, project_name: str) -> Optional[Dict[str, Any]]: + """Load project data""" + project_file = self.projects_dir / f"{project_name}.json" + if project_file.exists(): + try: + with open(project_file, "r") as f: + return json.load(f) + except Exception as e: + print(f"Error loading project: {e}") + return None + + def list_projects(self) -> list: + """List available projects""" + projects = [] + for project_file in self.projects_dir.glob("*.json"): + projects.append(project_file.stem) + return sorted(projects) + + def delete_project(self, project_name: str) -> bool: + """Delete a project""" + project_file = self.projects_dir / f"{project_name}.json" + try: + if project_file.exists(): + project_file.unlink() + return True + except Exception as e: + print(f"Error deleting project: {e}") + return False + + def get_cache_dir(self) -> Path: + """Get cache directory""" + cache_dir = self.config_dir / "cache" + cache_dir.mkdir(exist_ok=True) + return cache_dir + + def cleanup_cache(self, max_size_gb: float = None): + """Clean up cache directory""" + if max_size_gb is None: + max_size_gb = self._config.cache.max_cache_size_gb + + cache_dir = self.get_cache_dir() + if not cache_dir.exists(): + return + + # Calculate current cache size + total_size = 0 + cache_files = [] + + for file_path in cache_dir.rglob("*"): + if file_path.is_file(): + size = file_path.stat().st_size + total_size += size + cache_files.append((file_path, size, file_path.stat().st_mtime)) + + # Convert to GB + total_size_gb = total_size / (1024**3) + + if total_size_gb > max_size_gb: + # Sort by modification time (oldest first) + cache_files.sort(key=lambda x: x[2]) + + # Remove oldest files until under limit + target_size = max_size_gb * 0.8 # Remove to 80% of limit + current_size_gb = total_size_gb + + for file_path, size, _ in cache_files: + if current_size_gb <= target_size: + break + try: + file_path.unlink() + current_size_gb -= size / (1024**3) + except OSError: + pass + + def get_model_cache_dir(self) -> Path: + """Get model cache directory""" + model_dir = self.get_cache_dir() / "models" + model_dir.mkdir(exist_ok=True) + return model_dir + + def export_config(self, export_path: str): + """Export configuration to a file""" + try: + config_dict = { + "sam": asdict(self._config.sam), + "ui": asdict(self._config.ui), + "export": asdict(self._config.export), + "cache": asdict(self._config.cache), + "classes": self._config.classes, + } + + with open(export_path, "w") as f: + json.dump(config_dict, f, indent=2) + return True + except Exception as e: + print(f"Error exporting config: {e}") + return False + + def import_config(self, import_path: str) -> bool: + """Import configuration from a file""" + try: + with open(import_path, "r") as f: + config_dict = json.load(f) + + # Update configuration + if "sam" in config_dict: + self.update_sam_config(**config_dict["sam"]) + if "ui" in config_dict: + self.update_ui_config(**config_dict["ui"]) + if "export" in config_dict: + self.update_export_config(**config_dict["export"]) + if "cache" in config_dict: + self.update_cache_config(**config_dict["cache"]) + if "classes" in config_dict: + self._config.classes = config_dict["classes"] + self.save_config() + + return True + except Exception as e: + print(f"Error importing config: {e}") + return False + + +# Global configuration manager instance +_config_manager = None + + +def get_config_manager() -> ConfigManager: + """Get global configuration manager""" + global _config_manager + if _config_manager is None: + _config_manager = ConfigManager() + return _config_manager + + +def get_config() -> DataEngineConfig: + """Get current configuration""" + return get_config_manager().config diff --git a/data_engine/example.py b/data_engine/example.py new file mode 100644 index 0000000..23d9381 --- /dev/null +++ b/data_engine/example.py @@ -0,0 +1,208 @@ +#!/usr/bin/env python3 +""" +Example script demonstrating SAM2 Data Engine features +""" + +import sys +from pathlib import Path + +import numpy as np + +# Add data_engine to path +sys.path.insert(0, str(Path(__file__).parent)) + + +def create_sample_data(): + """Create some sample data for demonstration""" + print("Creating sample data...") + + # Create a simple test image + test_image = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8) + + # Add some shapes for segmentation + import cv2 + + # Draw a circle + cv2.circle(test_image, (200, 200), 50, (255, 0, 0), -1) + + # Draw a rectangle + cv2.rectangle(test_image, (400, 150), (500, 250), (0, 255, 0), -1) + + # Draw a triangle + points = np.array([[300, 350], [350, 300], [400, 350]], np.int32) + cv2.fillPoly(test_image, [points], (0, 0, 255)) + + return test_image + + +def demo_sam_processor(): + """Demonstrate SAM processor functionality""" + print("Testing SAM processor...") + + try: + from sam_processor import SAM2Processor + + # Initialize processor + processor = SAM2Processor() + + if not processor.is_loaded: + print("⚠ SAM model not loaded - this is expected without dependencies") + return False + + # Test with sample image + test_image = create_sample_data() + + # Test point segmentation + points = np.array([[200, 200], [400, 200]]) # Points in the shapes + labels = np.array([1, 1]) # Both positive + + result = processor.segment_with_points(test_image, points, labels) + + if result["success"]: + print("✓ SAM segmentation successful") + else: + print(f"✗ SAM segmentation failed: {result.get('error', 'Unknown error')}") + + return True + + except ImportError as e: + print(f"⚠ SAM processor import failed: {e}") + return False + + +def demo_utils(): + """Demonstrate utility functions""" + print("Testing utility functions...") + + try: + from utils import create_directory_structure, mask_to_polygon, polygon_to_mask + + # Test mask to polygon conversion + test_mask = np.zeros((100, 100), dtype=np.uint8) + test_mask[30:70, 30:70] = 255 # Square mask + + polygon = mask_to_polygon(test_mask) + print(f"✓ Converted mask to polygon with {len(polygon)//2} points") + + # Test polygon to mask conversion + reconstructed_mask = polygon_to_mask(polygon, 100, 100) + print(f"✓ Reconstructed mask shape: {reconstructed_mask.shape}") + + # Test directory structure creation + test_dir = Path(__file__).parent / "test_output" + directories = create_directory_structure(str(test_dir)) + print(f"✓ Created {len(directories)} directories") + + # Cleanup test directory + import shutil + + if test_dir.exists(): + shutil.rmtree(test_dir) + + return True + + except ImportError as e: + print(f"⚠ Utils import failed: {e}") + return False + except Exception as e: + print(f"✗ Utils test failed: {e}") + return False + + +def demo_config(): + """Demonstrate configuration management""" + print("Testing configuration...") + + try: + from config import ConfigManager + + # Create test config manager + test_config_dir = Path(__file__).parent / "test_config" + config_manager = ConfigManager(str(test_config_dir)) + + # Test configuration access + config = config_manager.config + print(f"✓ Loaded config with SAM model: {config.sam.model_name}") + + # Test configuration updates + config_manager.update_sam_config(model_name="sam2_l.pt") + print("✓ Updated SAM configuration") + + # Test project management + test_project_data = { + "video_path": "/test/video.mp4", + "annotations": {"frame_1": ["object_1"]}, + "classes": {0: "test_class"}, + } + + config_manager.save_project("test_project", test_project_data) + loaded_project = config_manager.load_project("test_project") + + if loaded_project: + print("✓ Project save/load successful") + else: + print("✗ Project save/load failed") + + # Cleanup test config + import shutil + + if test_config_dir.exists(): + shutil.rmtree(test_config_dir) + + return True + + except ImportError as e: + print(f"⚠ Config import failed: {e}") + return False + except Exception as e: + print(f"✗ Config test failed: {e}") + return False + + +def main(): + """Run all demonstrations""" + print("SAM2 Data Engine - Example and Test Script") + print("=" * 50) + + tests = [ + ("Utility Functions", demo_utils), + ("Configuration Management", demo_config), + ("SAM Processor", demo_sam_processor), + ] + + passed = 0 + total = len(tests) + + for test_name, test_func in tests: + print(f"\n--- {test_name} ---") + try: + if test_func(): + passed += 1 + print(f"✓ {test_name} passed") + else: + print(f"⚠ {test_name} completed with warnings") + except Exception as e: + print(f"✗ {test_name} failed: {e}") + + print(f"\n" + "=" * 50) + print(f"Tests completed: {passed}/{total} passed") + + if passed == total: + print("✓ All tests passed! The Data Engine should work correctly.") + elif passed > 0: + print( + "⚠ Some tests passed. Install missing dependencies for full functionality." + ) + else: + print("✗ Most tests failed. Please install dependencies and check setup.") + + print("\nTo install dependencies:") + print("pip install -r requirements.txt") + print("\nTo run the full application:") + print("python run.py") + + return 0 if passed > 0 else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/data_engine/main.py b/data_engine/main.py new file mode 100644 index 0000000..9fcf576 --- /dev/null +++ b/data_engine/main.py @@ -0,0 +1,849 @@ +#!/usr/bin/env python3 +""" +Data Engine GUI Application +An automatic data engine that uses visual prompts to interact with AI models +for generating YOLO training datasets using SAM2 segmentation. +""" + +import json +import os +import sys +from pathlib import Path +from typing import Dict, List, Optional, Tuple + +import cv2 +import numpy as np +import torch +from PIL import Image +from PySide6.QtCore import QRunnable, Qt, QThread, QThreadPool, QTimer, Signal +from PySide6.QtGui import QColor, QFont, QImage, QPainter, QPen, QPixmap +from PySide6.QtWidgets import ( + QApplication, + QCheckBox, + QComboBox, + QFileDialog, + QFrame, + QGroupBox, + QHBoxLayout, + QLabel, + QLineEdit, + QListWidget, + QListWidgetItem, + QMainWindow, + QMessageBox, + QProgressBar, + QPushButton, + QSlider, + QSpinBox, + QSplitter, + QTextEdit, + QVBoxLayout, + QWidget, +) + +try: + from ultralytics import SAM +except ImportError: + print("Warning: ultralytics not installed. Limited functionality.") + SAM = None + +# Import local modules +try: + from config import get_config_manager + from sam_processor import SAM2Processor + from utils import create_directory_structure, export_statistics +except ImportError as e: + print(f"Warning: Could not import local modules: {e}") + SAM2Processor = None + get_config_manager = None + create_directory_structure = None + export_statistics = None + + +class VideoProcessor(QThread): + """Thread for processing video frames and SAM2 operations""" + + frame_processed = Signal(int, np.ndarray) + progress_updated = Signal(int) + finished = Signal() + error_occurred = Signal(str) + + def __init__(self, video_path: str, output_dir: str): + super().__init__() + self.video_path = video_path + self.output_dir = output_dir + self.cache_dir = Path(output_dir) / "cache" + self.cache_dir.mkdir(exist_ok=True) + + def run(self): + try: + cap = cv2.VideoCapture(self.video_path) + total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) + + frame_idx = 0 + while True: + ret, frame = cap.read() + if not ret: + break + + # Cache frame + frame_path = self.cache_dir / f"frame_{frame_idx:06d}.jpg" + cv2.imwrite(str(frame_path), frame) + + self.frame_processed.emit(frame_idx, frame) + self.progress_updated.emit(int((frame_idx / total_frames) * 100)) + frame_idx += 1 + + cap.release() + self.finished.emit() + + except Exception as e: + self.error_occurred.emit(str(e)) + + +class SAMProcessor(QRunnable): + """Runnable for SAM2 segmentation processing""" + + def __init__(self, model, frame, points, labels, frame_idx, callback): + super().__init__() + self.model = model + self.frame = frame + self.points = points + self.labels = labels + self.frame_idx = frame_idx + self.callback = callback + + def run(self): + try: + # Process with SAM2 + results = self.model(self.frame, points=self.points, labels=self.labels) + self.callback(self.frame_idx, results) + except Exception as e: + print(f"SAM processing error: {e}") + + +class FrameViewer(QLabel): + """Custom QLabel for displaying frames with click interaction""" + + point_clicked = Signal( + int, int, int + ) # x, y, label (1 for positive, 0 for negative) + + def __init__(self): + super().__init__() + self.setMinimumSize(640, 480) + self.setStyleSheet("border: 2px solid gray;") + self.setScaledContents(True) + self.current_frame = None + self.scale_factor = 1.0 + self.click_mode = 1 # 1 for positive, 0 for negative + self.points = [] # List of (x, y, label) tuples + + def set_frame(self, frame: np.ndarray): + """Set the current frame to display""" + self.current_frame = frame.copy() + self.update_display() + + def set_click_mode(self, mode: int): + """Set click mode: 1 for positive points, 0 for negative points""" + self.click_mode = mode + + def add_point(self, x: int, y: int, label: int): + """Add a point to the current frame""" + self.points.append((x, y, label)) + self.update_display() + + def clear_points(self): + """Clear all points""" + self.points.clear() + self.update_display() + + def update_display(self): + """Update the display with current frame and points""" + if self.current_frame is None: + return + + display_frame = self.current_frame.copy() + + # Draw points + for x, y, label in self.points: + color = ( + (0, 255, 0) if label == 1 else (0, 0, 255) + ) # Green for positive, Red for negative + cv2.circle(display_frame, (x, y), 5, color, -1) + cv2.circle(display_frame, (x, y), 7, (255, 255, 255), 2) + + # Convert to QPixmap + height, width, channel = display_frame.shape + bytes_per_line = 3 * width + q_image = QImage( + display_frame.data, width, height, bytes_per_line, QImage.Format_RGB888 + ).rgbSwapped() + pixmap = QPixmap.fromImage(q_image) + self.setPixmap(pixmap) + + def mousePressEvent(self, event): + """Handle mouse click events""" + if self.current_frame is None: + return + + # Get click position relative to the actual image + widget_size = self.size() + pixmap_size = self.pixmap().size() if self.pixmap() else widget_size + + # Calculate scale factors + scale_x = self.current_frame.shape[1] / pixmap_size.width() + scale_y = self.current_frame.shape[0] / pixmap_size.height() + + # Convert widget coordinates to image coordinates + x = int(event.position().x() * scale_x) + y = int(event.position().y() * scale_y) + + # Ensure coordinates are within bounds + x = max(0, min(x, self.current_frame.shape[1] - 1)) + y = max(0, min(y, self.current_frame.shape[0] - 1)) + + self.add_point(x, y, self.click_mode) + self.point_clicked.emit(x, y, self.click_mode) + + +class ObjectClassManager(QWidget): + """Widget for managing object classes""" + + def __init__(self): + super().__init__() + self.classes = {} # id: name mapping + self.setup_ui() + + def setup_ui(self): + layout = QVBoxLayout() + + # Add class controls + add_layout = QHBoxLayout() + self.class_name_input = QLineEdit() + self.class_name_input.setPlaceholderText("Enter class name") + add_button = QPushButton("Add Class") + add_button.clicked.connect(self.add_class) + + add_layout.addWidget(QLabel("Class Name:")) + add_layout.addWidget(self.class_name_input) + add_layout.addWidget(add_button) + + # Class list + self.class_list = QListWidget() + + # Remove class button + remove_button = QPushButton("Remove Selected") + remove_button.clicked.connect(self.remove_selected_class) + + layout.addLayout(add_layout) + layout.addWidget(QLabel("Classes:")) + layout.addWidget(self.class_list) + layout.addWidget(remove_button) + + self.setLayout(layout) + + def add_class(self): + """Add a new class""" + name = self.class_name_input.text().strip() + if name and name not in self.classes.values(): + class_id = len(self.classes) + self.classes[class_id] = name + self.class_list.addItem(f"{class_id}: {name}") + self.class_name_input.clear() + + def remove_selected_class(self): + """Remove selected class""" + current_item = self.class_list.currentItem() + if current_item: + # Parse class ID from item text + text = current_item.text() + class_id = int(text.split(":")[0]) + + # Remove from classes dict + if class_id in self.classes: + del self.classes[class_id] + + # Remove from list + self.class_list.takeItem(self.class_list.row(current_item)) + + def get_current_class_id(self) -> Optional[int]: + """Get currently selected class ID""" + current_item = self.class_list.currentItem() + if current_item: + text = current_item.text() + return int(text.split(":")[0]) + return None + + def get_classes(self) -> Dict[int, str]: + """Get all classes""" + return self.classes.copy() + + +class DataEngineMainWindow(QMainWindow): + """Main window for the Data Engine application""" + + def __init__(self): + super().__init__() + self.setWindowTitle("SAM2 Data Engine - YOLO Dataset Generator") + self.setGeometry(100, 100, 1400, 900) + + # Initialize variables + self.video_path = None + self.output_dir = None + self.frames = [] + self.current_frame_idx = 0 + self.sam_model = None + self.frame_cache = {} + self.masks_cache = {} + self.annotations = {} # frame_idx: [annotations] + + # Thread pool for SAM processing + self.thread_pool = QThreadPool() + + self.setup_ui() + self.load_sam_model() + + def setup_ui(self): + """Setup the user interface""" + central_widget = QWidget() + self.setCentralWidget(central_widget) + + # Main layout + main_layout = QHBoxLayout() + + # Left panel - Controls + left_panel = self.create_left_panel() + + # Center panel - Frame viewer + center_panel = self.create_center_panel() + + # Right panel - Object classes and annotations + right_panel = self.create_right_panel() + + # Create splitter for resizable panels + splitter = QSplitter(Qt.Horizontal) + splitter.addWidget(left_panel) + splitter.addWidget(center_panel) + splitter.addWidget(right_panel) + splitter.setSizes([300, 700, 300]) + + main_layout.addWidget(splitter) + central_widget.setLayout(main_layout) + + def create_left_panel(self) -> QWidget: + """Create the left control panel""" + panel = QWidget() + layout = QVBoxLayout() + + # Video loading group + video_group = QGroupBox("Video Loading") + video_layout = QVBoxLayout() + + self.load_video_btn = QPushButton("Load Video") + self.load_video_btn.clicked.connect(self.load_video) + + self.video_path_label = QLabel("No video loaded") + self.video_path_label.setWordWrap(True) + + self.output_dir_btn = QPushButton("Set Output Directory") + self.output_dir_btn.clicked.connect(self.set_output_directory) + + self.output_dir_label = QLabel("No output directory set") + self.output_dir_label.setWordWrap(True) + + video_layout.addWidget(self.load_video_btn) + video_layout.addWidget(self.video_path_label) + video_layout.addWidget(self.output_dir_btn) + video_layout.addWidget(self.output_dir_label) + video_group.setLayout(video_layout) + + # Frame navigation group + nav_group = QGroupBox("Frame Navigation") + nav_layout = QVBoxLayout() + + # Frame slider + self.frame_slider = QSlider(Qt.Horizontal) + self.frame_slider.valueChanged.connect(self.on_frame_changed) + + # Frame controls + frame_controls = QHBoxLayout() + self.prev_btn = QPushButton("◀ Prev") + self.prev_btn.clicked.connect(self.prev_frame) + + self.frame_spinbox = QSpinBox() + self.frame_spinbox.valueChanged.connect(self.on_frame_spinbox_changed) + + self.next_btn = QPushButton("Next ▶") + self.next_btn.clicked.connect(self.next_frame) + + frame_controls.addWidget(self.prev_btn) + frame_controls.addWidget(self.frame_spinbox) + frame_controls.addWidget(self.next_btn) + + nav_layout.addWidget(QLabel("Frame:")) + nav_layout.addWidget(self.frame_slider) + nav_layout.addLayout(frame_controls) + nav_group.setLayout(nav_layout) + + # SAM controls group + sam_group = QGroupBox("SAM2 Controls") + sam_layout = QVBoxLayout() + + # Point selection mode + point_mode_layout = QHBoxLayout() + self.positive_point_btn = QPushButton("Positive Point") + self.positive_point_btn.setCheckable(True) + self.positive_point_btn.setChecked(True) + self.positive_point_btn.clicked.connect(lambda: self.set_point_mode(1)) + + self.negative_point_btn = QPushButton("Negative Point") + self.negative_point_btn.setCheckable(True) + self.negative_point_btn.clicked.connect(lambda: self.set_point_mode(0)) + + point_mode_layout.addWidget(self.positive_point_btn) + point_mode_layout.addWidget(self.negative_point_btn) + + # SAM action buttons + self.clear_points_btn = QPushButton("Clear Points") + self.clear_points_btn.clicked.connect(self.clear_points) + + self.segment_btn = QPushButton("Segment Object") + self.segment_btn.clicked.connect(self.segment_current_frame) + + # Propagation controls + prop_layout = QHBoxLayout() + self.propagate_forward_btn = QPushButton("Propagate Forward") + self.propagate_forward_btn.clicked.connect(self.propagate_forward) + + self.propagate_backward_btn = QPushButton("Propagate Backward") + self.propagate_backward_btn.clicked.connect(self.propagate_backward) + + prop_layout.addWidget(self.propagate_forward_btn) + prop_layout.addWidget(self.propagate_backward_btn) + + sam_layout.addLayout(point_mode_layout) + sam_layout.addWidget(self.clear_points_btn) + sam_layout.addWidget(self.segment_btn) + sam_layout.addLayout(prop_layout) + sam_group.setLayout(sam_layout) + + # Export group + export_group = QGroupBox("Export") + export_layout = QVBoxLayout() + + self.export_yolo_btn = QPushButton("Export YOLO Dataset") + self.export_yolo_btn.clicked.connect(self.export_yolo_dataset) + + self.progress_bar = QProgressBar() + + export_layout.addWidget(self.export_yolo_btn) + export_layout.addWidget(self.progress_bar) + export_group.setLayout(export_layout) + + # Add all groups to layout + layout.addWidget(video_group) + layout.addWidget(nav_group) + layout.addWidget(sam_group) + layout.addWidget(export_group) + layout.addStretch() + + panel.setLayout(layout) + return panel + + def create_center_panel(self) -> QWidget: + """Create the center frame viewer panel""" + panel = QWidget() + layout = QVBoxLayout() + + # Frame viewer + self.frame_viewer = FrameViewer() + self.frame_viewer.point_clicked.connect(self.on_point_clicked) + + layout.addWidget(self.frame_viewer) + panel.setLayout(layout) + return panel + + def create_right_panel(self) -> QWidget: + """Create the right panel for classes and annotations""" + panel = QWidget() + layout = QVBoxLayout() + + # Object class manager + self.class_manager = ObjectClassManager() + + # Current annotations + annotations_group = QGroupBox("Current Frame Annotations") + annotations_layout = QVBoxLayout() + + self.annotations_list = QListWidget() + + remove_annotation_btn = QPushButton("Remove Selected Annotation") + remove_annotation_btn.clicked.connect(self.remove_annotation) + + annotations_layout.addWidget(self.annotations_list) + annotations_layout.addWidget(remove_annotation_btn) + annotations_group.setLayout(annotations_layout) + + # Statistics + stats_group = QGroupBox("Statistics") + stats_layout = QVBoxLayout() + + self.stats_label = QTextEdit() + self.stats_label.setMaximumHeight(150) + self.stats_label.setReadOnly(True) + + stats_layout.addWidget(self.stats_label) + stats_group.setLayout(stats_layout) + + layout.addWidget(self.class_manager) + layout.addWidget(annotations_group) + layout.addWidget(stats_group) + + panel.setLayout(layout) + return panel + + def load_sam_model(self): + """Load the SAM2 model""" + try: + self.sam_model = SAM("sam2_b.pt") # Use SAM2 base model + print("SAM2 model loaded successfully") + except Exception as e: + QMessageBox.warning( + self, "Model Loading Error", f"Failed to load SAM2 model: {e}" + ) + + def load_video(self): + """Load a video file""" + file_path, _ = QFileDialog.getOpenFileName( + self, + "Select Video File", + "", + "Video Files (*.mp4 *.avi *.mov *.mkv *.wmv);;All Files (*)", + ) + + if file_path: + self.video_path = file_path + self.video_path_label.setText(f"Video: {Path(file_path).name}") + self.load_video_frames() + + def set_output_directory(self): + """Set the output directory for the dataset""" + dir_path = QFileDialog.getExistingDirectory(self, "Select Output Directory") + + if dir_path: + self.output_dir = dir_path + self.output_dir_label.setText(f"Output: {Path(dir_path).name}") + + def load_video_frames(self): + """Load frames from the video""" + if not self.video_path: + return + + try: + cap = cv2.VideoCapture(self.video_path) + total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) + + # Setup frame navigation + self.frame_slider.setMaximum(total_frames - 1) + self.frame_spinbox.setMaximum(total_frames - 1) + + # Cache first frame for immediate display + cap.set(cv2.CAP_PROP_POS_FRAMES, 0) + ret, frame = cap.read() + if ret: + self.frame_cache[0] = frame + self.frame_viewer.set_frame(frame) + + cap.release() + + # Start background frame caching + if self.output_dir: + self.cache_frames_async() + + self.update_stats() + + except Exception as e: + QMessageBox.critical(self, "Error", f"Failed to load video: {e}") + + def cache_frames_async(self): + """Cache frames asynchronously""" + cache_dir = Path(self.output_dir) / "cache" / "frames" + cache_dir.mkdir(parents=True, exist_ok=True) + + # Process video frames in background + self.video_processor = VideoProcessor(self.video_path, str(cache_dir)) + self.video_processor.frame_processed.connect(self.on_frame_cached) + self.video_processor.progress_updated.connect(self.progress_bar.setValue) + self.video_processor.start() + + def on_frame_cached(self, frame_idx: int, frame: np.ndarray): + """Handle cached frame""" + self.frame_cache[frame_idx] = frame + + def on_frame_changed(self, frame_idx: int): + """Handle frame slider change""" + self.current_frame_idx = frame_idx + self.frame_spinbox.setValue(frame_idx) + self.load_current_frame() + self.update_annotations_display() + + def on_frame_spinbox_changed(self, frame_idx: int): + """Handle frame spinbox change""" + self.frame_slider.setValue(frame_idx) + + def load_current_frame(self): + """Load and display the current frame""" + if self.current_frame_idx in self.frame_cache: + frame = self.frame_cache[self.current_frame_idx] + self.frame_viewer.set_frame(frame) + else: + # Load frame from video if not cached + self.load_frame_from_video(self.current_frame_idx) + + def load_frame_from_video(self, frame_idx: int): + """Load a specific frame from video""" + if not self.video_path: + return + + try: + cap = cv2.VideoCapture(self.video_path) + cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx) + ret, frame = cap.read() + cap.release() + + if ret: + self.frame_cache[frame_idx] = frame + self.frame_viewer.set_frame(frame) + except Exception as e: + print(f"Error loading frame {frame_idx}: {e}") + + def prev_frame(self): + """Go to previous frame""" + if self.current_frame_idx > 0: + self.frame_slider.setValue(self.current_frame_idx - 1) + + def next_frame(self): + """Go to next frame""" + max_frame = self.frame_slider.maximum() + if self.current_frame_idx < max_frame: + self.frame_slider.setValue(self.current_frame_idx + 1) + + def set_point_mode(self, mode: int): + """Set point selection mode""" + self.frame_viewer.set_click_mode(mode) + + # Update button states + self.positive_point_btn.setChecked(mode == 1) + self.negative_point_btn.setChecked(mode == 0) + + def clear_points(self): + """Clear all points on current frame""" + self.frame_viewer.clear_points() + + def on_point_clicked(self, x: int, y: int, label: int): + """Handle point click on frame""" + print(f"Point clicked: ({x}, {y}), label: {label}") + + def segment_current_frame(self): + """Segment object in current frame using SAM2""" + if not self.sam_model or self.current_frame_idx not in self.frame_cache: + QMessageBox.warning(self, "Error", "No model loaded or frame not available") + return + + if not self.frame_viewer.points: + QMessageBox.warning(self, "Error", "Please add at least one point") + return + + current_class_id = self.class_manager.get_current_class_id() + if current_class_id is None: + QMessageBox.warning(self, "Error", "Please select a class") + return + + # Prepare points and labels for SAM + points = np.array([[x, y] for x, y, _ in self.frame_viewer.points]) + labels = np.array([label for _, _, label in self.frame_viewer.points]) + + frame = self.frame_cache[self.current_frame_idx] + + # Run SAM segmentation + try: + results = self.sam_model(frame, points=points, labels=labels) + + if results and len(results) > 0: + result = results[0] + if hasattr(result, "masks") and result.masks is not None: + # Get the best mask + mask = result.masks.data[0].cpu().numpy() + + # Store annotation + self.store_annotation( + self.current_frame_idx, mask, current_class_id + ) + self.update_annotations_display() + + # Cache mask + self.cache_mask(self.current_frame_idx, mask, current_class_id) + + except Exception as e: + QMessageBox.critical(self, "Segmentation Error", f"Failed to segment: {e}") + + def store_annotation(self, frame_idx: int, mask: np.ndarray, class_id: int): + """Store annotation for a frame""" + if frame_idx not in self.annotations: + self.annotations[frame_idx] = [] + + annotation = { + "mask": mask, + "class_id": class_id, + "class_name": self.class_manager.classes.get(class_id, "unknown"), + } + + self.annotations[frame_idx].append(annotation) + + def cache_mask(self, frame_idx: int, mask: np.ndarray, class_id: int): + """Cache mask to disk""" + if not self.output_dir: + return + + cache_dir = Path(self.output_dir) / "cache" / "masks" + cache_dir.mkdir(parents=True, exist_ok=True) + + mask_path = cache_dir / f"frame_{frame_idx:06d}_class_{class_id}.pt" + torch.save(torch.from_numpy(mask), mask_path) + + def propagate_forward(self): + """Propagate segmentation forward""" + # TODO: Implement SAM2 video tracking for forward propagation + QMessageBox.information(self, "Info", "Forward propagation not yet implemented") + + def propagate_backward(self): + """Propagate segmentation backward""" + # TODO: Implement SAM2 video tracking for backward propagation + QMessageBox.information( + self, "Info", "Backward propagation not yet implemented" + ) + + def update_annotations_display(self): + """Update the annotations list for current frame""" + self.annotations_list.clear() + + if self.current_frame_idx in self.annotations: + for i, annotation in enumerate(self.annotations[self.current_frame_idx]): + class_name = annotation["class_name"] + item_text = f"Object {i}: {class_name}" + self.annotations_list.addItem(item_text) + + def remove_annotation(self): + """Remove selected annotation""" + current_item = self.annotations_list.currentItem() + if current_item and self.current_frame_idx in self.annotations: + row = self.annotations_list.row(current_item) + if 0 <= row < len(self.annotations[self.current_frame_idx]): + del self.annotations[self.current_frame_idx][row] + self.update_annotations_display() + + def export_yolo_dataset(self): + """Export annotations in YOLO format""" + if not self.output_dir: + QMessageBox.warning(self, "Error", "Please set output directory first") + return + + if not self.annotations: + QMessageBox.warning(self, "Error", "No annotations to export") + return + + try: + self.create_yolo_dataset() + QMessageBox.information( + self, "Success", "YOLO dataset exported successfully" + ) + except Exception as e: + QMessageBox.critical(self, "Export Error", f"Failed to export dataset: {e}") + + def create_yolo_dataset(self): + """Create YOLO format dataset""" + dataset_dir = Path(self.output_dir) / "yolo_dataset" + images_dir = dataset_dir / "images" + labels_dir = dataset_dir / "labels" + + images_dir.mkdir(parents=True, exist_ok=True) + labels_dir.mkdir(parents=True, exist_ok=True) + + # Create classes.txt + classes_file = dataset_dir / "classes.txt" + with open(classes_file, "w") as f: + classes = self.class_manager.get_classes() + for class_id in sorted(classes.keys()): + f.write(f"{classes[class_id]}\n") + + # Export annotated frames + for frame_idx, annotations in self.annotations.items(): + if frame_idx not in self.frame_cache: + continue + + # Save image + frame = self.frame_cache[frame_idx] + image_path = images_dir / f"frame_{frame_idx:06d}.jpg" + cv2.imwrite(str(image_path), frame) + + # Save labels + label_path = labels_dir / f"frame_{frame_idx:06d}.txt" + with open(label_path, "w") as f: + for annotation in annotations: + # Convert mask to YOLO segmentation format + mask = annotation["mask"] + class_id = annotation["class_id"] + + # Find contours from mask + mask_uint8 = (mask * 255).astype(np.uint8) + contours, _ = cv2.findContours( + mask_uint8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE + ) + + if contours: + # Use the largest contour + largest_contour = max(contours, key=cv2.contourArea) + + # Normalize coordinates + h, w = frame.shape[:2] + normalized_contour = [] + + for point in largest_contour: + x, y = point[0] + normalized_contour.extend([x / w, y / h]) + + # Write YOLO segmentation line + if len(normalized_contour) >= 6: # At least 3 points + line = f"{class_id} " + " ".join( + [f"{coord:.6f}" for coord in normalized_contour] + ) + f.write(line + "\n") + + def update_stats(self): + """Update statistics display""" + total_frames = len(self.frame_cache) + annotated_frames = len(self.annotations) + total_annotations = sum(len(anns) for anns in self.annotations.values()) + + stats_text = f""" +Total Frames: {total_frames} +Annotated Frames: {annotated_frames} +Total Annotations: {total_annotations} +Current Frame: {self.current_frame_idx} + """ + + self.stats_label.setText(stats_text.strip()) + + +def main(): + app = QApplication(sys.argv) + + window = DataEngineMainWindow() + window.show() + + sys.exit(app.exec()) + + +if __name__ == "__main__": + main() diff --git a/data_engine/requirements.txt b/data_engine/requirements.txt new file mode 100644 index 0000000..8473fac --- /dev/null +++ b/data_engine/requirements.txt @@ -0,0 +1,8 @@ +PySide6>=6.5.0 +ultralytics>=8.0.0 +opencv-python>=4.8.0 +numpy>=1.21.0 +Pillow>=9.0.0 +torch>=1.13.0 +torchvision>=0.14.0 +matplotlib>=3.5.0 diff --git a/data_engine/run.py b/data_engine/run.py new file mode 100644 index 0000000..243ed5d --- /dev/null +++ b/data_engine/run.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 +""" +Launch script for the SAM2 Data Engine +""" + +import os +import sys +from pathlib import Path + +# Add the data_engine directory to Python path +data_engine_dir = Path(__file__).parent +sys.path.insert(0, str(data_engine_dir)) + + +def check_dependencies(): + """Check if all required dependencies are installed""" + missing_deps = [] + + try: + import cv2 + except ImportError: + missing_deps.append("opencv-python") + + try: + import numpy + except ImportError: + missing_deps.append("numpy") + + try: + import torch + except ImportError: + missing_deps.append("torch") + + try: + from PySide6 import QtWidgets + except ImportError: + missing_deps.append("PySide6") + + try: + from ultralytics import SAM + except ImportError: + missing_deps.append("ultralytics") + + try: + from PIL import Image + except ImportError: + missing_deps.append("Pillow") + + if missing_deps: + print("Missing dependencies:") + for dep in missing_deps: + print(f" - {dep}") + print("\nPlease install missing dependencies:") + print(f"pip install {' '.join(missing_deps)}") + print("\nOr run the setup script:") + print("python setup.py") + return False + + return True + + +def main(): + """Main launch function""" + print("SAM2 Data Engine") + print("=" * 30) + + # Check dependencies + if not check_dependencies(): + print("\nDependency check failed!") + return 1 + + print("✓ All dependencies found") + + # Check for CUDA + try: + import torch + + if torch.cuda.is_available(): + print(f"✓ CUDA available: {torch.cuda.get_device_name()}") + else: + print("⚠ CUDA not available, using CPU") + except: + print("⚠ Could not check CUDA availability") + + # Launch the application + try: + print("\nLaunching Data Engine...") + from main import main as app_main + + return app_main() + except ImportError as e: + print(f"Error importing main application: {e}") + return 1 + except Exception as e: + print(f"Error launching application: {e}") + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/data_engine/sam_processor.py b/data_engine/sam_processor.py new file mode 100644 index 0000000..763ada9 --- /dev/null +++ b/data_engine/sam_processor.py @@ -0,0 +1,510 @@ +#!/usr/bin/env python3 +""" +SAM2 Integration Module +Handles SAM2 model loading, inference, and video tracking +""" + +import os +from pathlib import Path +from typing import Any, Dict, List, Optional, Tuple + +import cv2 +import numpy as np +import torch + +try: + from ultralytics import SAM +except ImportError: + print("Warning: ultralytics not installed. SAM functionality will be limited.") + SAM = None + + +class SAM2Processor: + """SAM2 model processor for image segmentation and video tracking""" + + def __init__(self, model_path: str = "sam2_b.pt", device: str = "auto"): + """ + Initialize SAM2 processor + + Args: + model_path: Path to SAM2 model file + device: Device to run model on ('cpu', 'cuda', 'auto') + """ + self.model_path = model_path + self.device = self._get_device(device) + self.model = None + self.is_loaded = False + + # Video tracking state + self.tracking_state = {} + self.current_video_features = None + + self.load_model() + + def _get_device(self, device: str) -> str: + """Determine the best device to use""" + if device == "auto": + return "cuda" if torch.cuda.is_available() else "cpu" + return device + + def load_model(self) -> bool: + """ + Load the SAM2 model + + Returns: + True if model loaded successfully + """ + try: + if SAM is None: + print("SAM not available - ultralytics not installed") + return False + + self.model = SAM(self.model_path) + self.is_loaded = True + print(f"SAM2 model loaded successfully on {self.device}") + return True + + except Exception as e: + print(f"Failed to load SAM2 model: {e}") + self.is_loaded = False + return False + + def segment_with_points( + self, + image: np.ndarray, + points: np.ndarray, + labels: np.ndarray, + multimask_output: bool = False, + ) -> Dict[str, Any]: + """ + Segment image using point prompts + + Args: + image: Input image (RGB) + points: Array of point coordinates [[x1, y1], [x2, y2], ...] + labels: Array of point labels [1, 0, 1, ...] (1=positive, 0=negative) + multimask_output: Whether to output multiple masks + + Returns: + Dictionary containing masks and other outputs + """ + if not self.is_loaded: + return {"masks": None, "error": "Model not loaded"} + + try: + # Run SAM2 prediction + results = self.model(image, points=points, labels=labels) + + if results and len(results) > 0: + result = results[0] + + output = { + "masks": None, + "scores": None, + "logits": None, + "success": True, + } + + if hasattr(result, "masks") and result.masks is not None: + # Extract mask data + masks = result.masks.data.cpu().numpy() + output["masks"] = masks + + # Extract scores if available + if hasattr(result.masks, "conf"): + output["scores"] = result.masks.conf.cpu().numpy() + + return output + else: + return { + "masks": None, + "error": "No results from model", + "success": False, + } + + except Exception as e: + return {"masks": None, "error": str(e), "success": False} + + def segment_with_box(self, image: np.ndarray, box: List[int]) -> Dict[str, Any]: + """ + Segment image using bounding box prompt + + Args: + image: Input image (RGB) + box: Bounding box [x1, y1, x2, y2] + + Returns: + Dictionary containing masks and other outputs + """ + if not self.is_loaded: + return {"masks": None, "error": "Model not loaded"} + + try: + results = self.model(image, bboxes=[box]) + + if results and len(results) > 0: + result = results[0] + + output = {"masks": None, "scores": None, "success": True} + + if hasattr(result, "masks") and result.masks is not None: + masks = result.masks.data.cpu().numpy() + output["masks"] = masks + + if hasattr(result.masks, "conf"): + output["scores"] = result.masks.conf.cpu().numpy() + + return output + else: + return { + "masks": None, + "error": "No results from model", + "success": False, + } + + except Exception as e: + return {"masks": None, "error": str(e), "success": False} + + def initialize_video_tracking(self, first_frame: np.ndarray) -> bool: + """ + Initialize video tracking with the first frame + + Args: + first_frame: First frame of the video + + Returns: + True if initialization successful + """ + try: + # This would typically encode the first frame for tracking + # For now, we'll store the frame and prepare for tracking + self.tracking_state = { + "initialized": True, + "frame_count": 0, + "objects": {}, # object_id -> tracking_info + } + + # In a full SAM2 implementation, this would: + # 1. Encode the frame with the image encoder + # 2. Store image features for efficient tracking + # 3. Initialize memory banks for object tracking + + return True + + except Exception as e: + print(f"Failed to initialize video tracking: {e}") + return False + + def add_tracking_object( + self, frame: np.ndarray, points: np.ndarray, labels: np.ndarray, object_id: int + ) -> bool: + """ + Add a new object to track in the video + + Args: + frame: Current frame + points: Point prompts + labels: Point labels + object_id: Unique ID for the object + + Returns: + True if object added successfully + """ + try: + # Segment the object in the current frame + result = self.segment_with_points(frame, points, labels) + + if result["success"] and result["masks"] is not None: + # Store object information for tracking + self.tracking_state["objects"][object_id] = { + "mask": result["masks"][0], # Use the best mask + "last_frame": self.tracking_state["frame_count"], + "points": points, + "labels": labels, + } + return True + + return False + + except Exception as e: + print(f"Failed to add tracking object: {e}") + return False + + def propagate_masks( + self, frames: List[np.ndarray], start_frame_idx: int, direction: str = "forward" + ) -> Dict[int, Dict[int, np.ndarray]]: + """ + Propagate masks across multiple frames + + Args: + frames: List of frames to process + start_frame_idx: Index of the starting frame + direction: 'forward' or 'backward' + + Returns: + Dictionary mapping frame_idx -> {object_id -> mask} + """ + results = {} + + if not self.tracking_state.get("initialized", False): + return results + + try: + # For each frame, propagate masks for all tracked objects + frame_indices = range(len(frames)) + if direction == "backward": + frame_indices = reversed(frame_indices) + + for frame_idx in frame_indices: + if frame_idx == start_frame_idx: + continue + + frame = frames[frame_idx] + frame_results = {} + + # Propagate each tracked object + for object_id, obj_info in self.tracking_state["objects"].items(): + # In a full SAM2 implementation, this would: + # 1. Use temporal features from previous frames + # 2. Apply object tracking algorithms + # 3. Refine masks based on motion and appearance + + # For now, we'll use a simplified approach + propagated_mask = self._simple_mask_propagation( + frame, + obj_info["mask"], + obj_info.get("points"), + obj_info.get("labels"), + ) + + if propagated_mask is not None: + frame_results[object_id] = propagated_mask + + if frame_results: + results[frame_idx] = frame_results + + return results + + except Exception as e: + print(f"Failed to propagate masks: {e}") + return {} + + def _simple_mask_propagation( + self, + frame: np.ndarray, + reference_mask: np.ndarray, + points: Optional[np.ndarray] = None, + labels: Optional[np.ndarray] = None, + ) -> Optional[np.ndarray]: + """ + Simple mask propagation using template matching or re-segmentation + + Args: + frame: Current frame + reference_mask: Mask from previous frame + points: Original point prompts (optional) + labels: Original point labels (optional) + + Returns: + Propagated mask or None if failed + """ + try: + # Method 1: If we have original points, re-segment + if points is not None and labels is not None: + result = self.segment_with_points(frame, points, labels) + if result["success"] and result["masks"] is not None: + return result["masks"][0] + + # Method 2: Use template matching or other computer vision techniques + # This is a placeholder for more sophisticated tracking + # In practice, SAM2 would use temporal attention and memory mechanisms + + return None + + except Exception as e: + print(f"Simple mask propagation failed: {e}") + return None + + def save_features_cache( + self, cache_path: str, frame_idx: int, features: torch.Tensor + ): + """ + Save encoded features to cache for faster processing + + Args: + cache_path: Path to cache directory + frame_idx: Frame index + features: Encoded features tensor + """ + try: + cache_dir = Path(cache_path) + cache_dir.mkdir(parents=True, exist_ok=True) + + features_file = cache_dir / f"features_frame_{frame_idx:06d}.pt" + torch.save(features, features_file) + + except Exception as e: + print(f"Failed to save features cache: {e}") + + def load_features_cache( + self, cache_path: str, frame_idx: int + ) -> Optional[torch.Tensor]: + """ + Load encoded features from cache + + Args: + cache_path: Path to cache directory + frame_idx: Frame index + + Returns: + Cached features tensor or None if not found + """ + try: + cache_dir = Path(cache_path) + features_file = cache_dir / f"features_frame_{frame_idx:06d}.pt" + + if features_file.exists(): + return torch.load(features_file, map_location=self.device) + + return None + + except Exception as e: + print(f"Failed to load features cache: {e}") + return None + + def clear_tracking_state(self): + """Clear all tracking state""" + self.tracking_state = {} + self.current_video_features = None + + def get_model_info(self) -> Dict[str, Any]: + """ + Get information about the loaded model + + Returns: + Dictionary with model information + """ + info = { + "model_path": self.model_path, + "device": self.device, + "is_loaded": self.is_loaded, + "tracking_initialized": self.tracking_state.get("initialized", False), + "tracked_objects_count": len(self.tracking_state.get("objects", {})), + } + + if self.model and hasattr(self.model, "model"): + try: + # Try to get model parameters info + total_params = sum(p.numel() for p in self.model.model.parameters()) + info["total_parameters"] = total_params + except: + pass + + return info + + +def create_sam_processor( + model_name: str = "sam2_b.pt", device: str = "auto" +) -> SAM2Processor: + """ + Factory function to create SAM2 processor + + Args: + model_name: Name of the SAM2 model + device: Device to run on + + Returns: + SAM2Processor instance + """ + return SAM2Processor(model_name, device) + + +# Utility functions for SAM2 integration + + +def visualize_masks( + image: np.ndarray, + masks: List[np.ndarray], + colors: Optional[List[Tuple[int, int, int]]] = None, + alpha: float = 0.5, +) -> np.ndarray: + """ + Visualize multiple masks on an image + + Args: + image: Base image + masks: List of binary masks + colors: Colors for each mask + alpha: Transparency + + Returns: + Image with mask overlays + """ + if not masks: + return image + + result = image.copy() + + # Generate colors if not provided + if colors is None: + colors = [] + for i in range(len(masks)): + # Generate distinct colors + hue = (i * 137.5) % 360 # Golden angle approximation + color = tuple( + int(c) + for c in cv2.cvtColor(np.uint8([[[hue, 255, 255]]]), cv2.COLOR_HSV2RGB)[ + 0 + ][0] + ) + colors.append(color) + + # Apply each mask + for mask, color in zip(masks, colors): + if len(mask.shape) > 2: + mask = mask[0] # Take first mask if multiple + + mask_colored = np.zeros_like(image) + mask_colored[mask > 0] = color + + result = cv2.addWeighted(result, 1 - alpha, mask_colored, alpha, 0) + + return result + + +def masks_to_rle(masks: List[np.ndarray]) -> List[Dict]: + """ + Convert masks to Run-Length Encoding format + + Args: + masks: List of binary masks + + Returns: + List of RLE dictionaries + """ + rle_list = [] + + for mask in masks: + if len(mask.shape) > 2: + mask = mask[0] + + # Simple RLE encoding + flat_mask = mask.flatten() + rle = [] + current_val = flat_mask[0] + count = 1 + + for val in flat_mask[1:]: + if val == current_val: + count += 1 + else: + rle.extend([count, current_val]) + current_val = val + count = 1 + + rle.extend([count, current_val]) + + rle_dict = {"counts": rle, "size": list(mask.shape)} + rle_list.append(rle_dict) + + return rle_list diff --git a/data_engine/setup.py b/data_engine/setup.py new file mode 100644 index 0000000..7cf6355 --- /dev/null +++ b/data_engine/setup.py @@ -0,0 +1,136 @@ +#!/usr/bin/env python3 +""" +Setup script for the SAM2 Data Engine +""" + +import os +import subprocess +import sys +from pathlib import Path + + +def install_requirements(): + """Install required packages""" + requirements_file = Path(__file__).parent / "requirements.txt" + + if not requirements_file.exists(): + print("Requirements file not found!") + return False + + try: + print("Installing requirements...") + subprocess.check_call( + [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)] + ) + print("Requirements installed successfully!") + return True + except subprocess.CalledProcessError as e: + print(f"Failed to install requirements: {e}") + return False + + +def download_sam_models(): + """Download SAM2 models""" + try: + print("Downloading SAM2 models...") + # This will download the model when first used + from ultralytics import SAM + + # Try to load different SAM2 models + models = ["sam2_b.pt", "sam2_l.pt", "sam2_s.pt"] + + for model_name in models: + try: + print(f"Downloading {model_name}...") + sam = SAM(model_name) + print(f"✓ {model_name} downloaded successfully") + break # Download at least one model + except Exception as e: + print(f"Failed to download {model_name}: {e}") + continue + + return True + + except ImportError: + print("Ultralytics not installed. Please install requirements first.") + return False + except Exception as e: + print(f"Failed to download models: {e}") + return False + + +def create_directories(): + """Create necessary directories""" + base_dir = Path(__file__).parent + directories = [ + "cache", + "cache/frames", + "cache/masks", + "cache/features", + "projects", + "exports", + ] + + for dir_name in directories: + dir_path = base_dir / dir_name + dir_path.mkdir(parents=True, exist_ok=True) + print(f"Created directory: {dir_path}") + + +def check_system_requirements(): + """Check system requirements""" + print("Checking system requirements...") + + # Check Python version + if sys.version_info < (3, 8): + print("Error: Python 3.8 or higher is required") + return False + + print(f"✓ Python {sys.version_info.major}.{sys.version_info.minor}") + + # Check for CUDA (optional) + try: + import torch + + if torch.cuda.is_available(): + print(f"✓ CUDA available: {torch.cuda.get_device_name()}") + else: + print("⚠ CUDA not available, will use CPU (slower)") + except ImportError: + print("⚠ PyTorch not installed yet") + + return True + + +def main(): + """Main setup function""" + print("=" * 50) + print("SAM2 Data Engine Setup") + print("=" * 50) + + # Check system requirements + if not check_system_requirements(): + return False + + # Install requirements + if not install_requirements(): + return False + + # Create directories + create_directories() + + # Download models + if not download_sam_models(): + print("⚠ Model download failed, but you can try again later") + + print("\n" + "=" * 50) + print("Setup completed!") + print("You can now run the data engine with: python main.py") + print("=" * 50) + + return True + + +if __name__ == "__main__": + success = main() + sys.exit(0 if success else 1) diff --git a/data_engine/utils.py b/data_engine/utils.py new file mode 100644 index 0000000..7cbee43 --- /dev/null +++ b/data_engine/utils.py @@ -0,0 +1,368 @@ +#!/usr/bin/env python3 +""" +Utility functions for the Data Engine application +""" + +import json +import os +from pathlib import Path +from typing import Dict, List, Optional, Tuple + +import cv2 +import numpy as np +import torch + + +def mask_to_polygon( + mask: np.ndarray, epsilon_factor: float = 0.01 +) -> List[List[float]]: + """ + Convert a binary mask to polygon coordinates in YOLO format + + Args: + mask: Binary mask as numpy array + epsilon_factor: Factor for polygon approximation (smaller = more precise) + + Returns: + List of normalized coordinates [x1, y1, x2, y2, ...] + """ + # Find contours + contours, _ = cv2.findContours( + mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE + ) + + if not contours: + return [] + + # Get the largest contour + largest_contour = max(contours, key=cv2.contourArea) + + # Approximate polygon to reduce points + epsilon = epsilon_factor * cv2.arcLength(largest_contour, True) + approx_polygon = cv2.approxPolyDP(largest_contour, epsilon, True) + + # Extract coordinates and normalize + h, w = mask.shape + normalized_coords = [] + + for point in approx_polygon: + x, y = point[0] + normalized_coords.extend([x / w, y / h]) + + return normalized_coords + + +def polygon_to_mask( + polygon: List[float], img_height: int, img_width: int +) -> np.ndarray: + """ + Convert polygon coordinates to binary mask + + Args: + polygon: List of normalized coordinates [x1, y1, x2, y2, ...] + img_height: Image height + img_width: Image width + + Returns: + Binary mask as numpy array + """ + # Convert normalized coordinates back to pixel coordinates + points = [] + for i in range(0, len(polygon), 2): + x = int(polygon[i] * img_width) + y = int(polygon[i + 1] * img_height) + points.append([x, y]) + + # Create mask + mask = np.zeros((img_height, img_width), dtype=np.uint8) + if len(points) >= 3: + cv2.fillPoly(mask, [np.array(points, dtype=np.int32)], 255) + + return mask + + +def save_project_config(config: Dict, config_path: str): + """Save project configuration to JSON file""" + with open(config_path, "w") as f: + json.dump(config, f, indent=2) + + +def load_project_config(config_path: str) -> Dict: + """Load project configuration from JSON file""" + if os.path.exists(config_path): + with open(config_path, "r") as f: + return json.load(f) + return {} + + +def create_yolo_yaml(classes: Dict[int, str], dataset_path: str) -> str: + """ + Create YOLO dataset YAML configuration file + + Args: + classes: Dictionary mapping class IDs to class names + dataset_path: Path to the dataset directory + + Returns: + Path to the created YAML file + """ + yaml_content = f"""# YOLO Dataset Configuration +# Generated by SAM2 Data Engine + +path: {dataset_path} # dataset root dir +train: images # train images (relative to 'path') +val: images # val images (relative to 'path') +test: # test images (optional) + +# Classes +nc: {len(classes)} # number of classes +names: {list(classes.values())} # class names +""" + + yaml_path = Path(dataset_path) / "dataset.yaml" + with open(yaml_path, "w") as f: + f.write(yaml_content) + + return str(yaml_path) + + +def validate_yolo_annotation( + annotation_line: str, img_width: int, img_height: int +) -> bool: + """ + Validate a YOLO annotation line + + Args: + annotation_line: YOLO format annotation string + img_width: Image width + img_height: Image height + + Returns: + True if annotation is valid + """ + try: + parts = annotation_line.strip().split() + if len(parts) < 7: # class_id + at least 3 coordinate pairs + return False + + # Check class ID + class_id = int(parts[0]) + if class_id < 0: + return False + + # Check coordinates + coords = [float(x) for x in parts[1:]] + if len(coords) % 2 != 0: # Must be pairs + return False + + # Check coordinate bounds + for i in range(0, len(coords), 2): + x, y = coords[i], coords[i + 1] + if not (0 <= x <= 1 and 0 <= y <= 1): + return False + + return True + + except (ValueError, IndexError): + return False + + +def calculate_mask_area(mask: np.ndarray) -> float: + """Calculate the area of a binary mask as percentage of image""" + total_pixels = mask.shape[0] * mask.shape[1] + mask_pixels = np.sum(mask > 0) + return (mask_pixels / total_pixels) * 100 + + +def get_mask_bbox(mask: np.ndarray) -> Tuple[int, int, int, int]: + """ + Get bounding box coordinates from binary mask + + Returns: + Tuple of (x_min, y_min, x_max, y_max) + """ + rows = np.any(mask, axis=1) + cols = np.any(mask, axis=0) + + if not np.any(rows) or not np.any(cols): + return (0, 0, 0, 0) + + y_min, y_max = np.where(rows)[0][[0, -1]] + x_min, x_max = np.where(cols)[0][[0, -1]] + + return (x_min, y_min, x_max, y_max) + + +def resize_mask(mask: np.ndarray, target_size: Tuple[int, int]) -> np.ndarray: + """ + Resize a binary mask to target size + + Args: + mask: Binary mask + target_size: (width, height) + + Returns: + Resized mask + """ + return cv2.resize( + mask.astype(np.uint8), target_size, interpolation=cv2.INTER_NEAREST + ) + + +def merge_masks(masks: List[np.ndarray]) -> np.ndarray: + """ + Merge multiple binary masks into one + + Args: + masks: List of binary masks + + Returns: + Merged mask + """ + if not masks: + return np.array([]) + + result = masks[0].copy() + for mask in masks[1:]: + result = np.logical_or(result, mask) + + return result.astype(np.uint8) + + +def apply_mask_overlay( + image: np.ndarray, + mask: np.ndarray, + color: Tuple[int, int, int] = (0, 255, 0), + alpha: float = 0.5, +) -> np.ndarray: + """ + Apply a colored mask overlay to an image + + Args: + image: RGB image + mask: Binary mask + color: RGB color for the overlay + alpha: Transparency of the overlay + + Returns: + Image with mask overlay + """ + overlay = image.copy() + overlay[mask > 0] = color + + return cv2.addWeighted(image, 1 - alpha, overlay, alpha, 0) + + +def extract_frame_info(video_path: str) -> Dict: + """ + Extract information from video file + + Args: + video_path: Path to video file + + Returns: + Dictionary with video information + """ + cap = cv2.VideoCapture(video_path) + + info = { + "total_frames": int(cap.get(cv2.CAP_PROP_FRAME_COUNT)), + "fps": cap.get(cv2.CAP_PROP_FPS), + "width": int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), + "height": int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)), + "duration": int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) / cap.get(cv2.CAP_PROP_FPS) + if cap.get(cv2.CAP_PROP_FPS) > 0 + else 0, + } + + cap.release() + return info + + +def create_directory_structure(base_path: str) -> Dict[str, str]: + """ + Create the directory structure for the data engine project + + Args: + base_path: Base directory path + + Returns: + Dictionary mapping folder names to paths + """ + base_path = Path(base_path) + + directories = { + "cache": base_path / "cache", + "frames": base_path / "cache" / "frames", + "masks": base_path / "cache" / "masks", + "features": base_path / "cache" / "features", + "yolo_dataset": base_path / "yolo_dataset", + "images": base_path / "yolo_dataset" / "images", + "labels": base_path / "yolo_dataset" / "labels", + "configs": base_path / "configs", + "exports": base_path / "exports", + } + + # Create all directories + for dir_path in directories.values(): + dir_path.mkdir(parents=True, exist_ok=True) + + return {name: str(path) for name, path in directories.items()} + + +def cleanup_cache(cache_dir: str, keep_recent: int = 100): + """ + Clean up old cache files, keeping only the most recent ones + + Args: + cache_dir: Path to cache directory + keep_recent: Number of recent files to keep + """ + cache_path = Path(cache_dir) + if not cache_path.exists(): + return + + # Get all files sorted by modification time + files = sorted(cache_path.glob("*"), key=lambda x: x.stat().st_mtime, reverse=True) + + # Remove old files + for file_path in files[keep_recent:]: + try: + file_path.unlink() + except OSError: + pass # Ignore errors + + +def export_statistics(annotations: Dict, output_path: str): + """ + Export annotation statistics to JSON file + + Args: + annotations: Dictionary of annotations by frame + output_path: Path to output JSON file + """ + stats = { + "total_frames": len(annotations), + "total_annotations": sum(len(anns) for anns in annotations.values()), + "annotations_per_frame": { + str(frame_idx): len(anns) for frame_idx, anns in annotations.items() + }, + "class_distribution": {}, + "average_annotations_per_frame": sum(len(anns) for anns in annotations.values()) + / len(annotations) + if annotations + else 0, + } + + # Calculate class distribution + for frame_annotations in annotations.values(): + for annotation in frame_annotations: + class_id = annotation.get("class_id", "unknown") + class_name = annotation.get("class_name", "unknown") + key = f"{class_id}_{class_name}" + stats["class_distribution"][key] = ( + stats["class_distribution"].get(key, 0) + 1 + ) + + with open(output_path, "w") as f: + json.dump(stats, f, indent=2) From 9bd6998e2298f132af9262238e25fb1b3dda0dc5 Mon Sep 17 00:00:00 2001 From: Cruiz102 Date: Sun, 22 Jun 2025 14:22:26 -0400 Subject: [PATCH 2/8] added sam2 submodule and gui folder. --- .gitmodules | 3 + data_engine/.dockerignore | 118 ++++ data_engine/Dockerfile | 39 ++ data_engine/Makefile | 100 --- data_engine/README.md | 26 + data_engine/docker-compose.yml | 69 ++ data_engine/example.py | 208 ------ data_engine/gui/README.md | 75 +++ data_engine/gui/__init__.py | 23 + data_engine/gui/center_panel.py | 25 + data_engine/gui/frame_viewer.py | 94 +++ data_engine/gui/left_panel.py | 149 +++++ data_engine/gui/main_window.py | 465 +++++++++++++ data_engine/gui/object_class_manager.py | 88 +++ data_engine/gui/right_panel.py | 71 ++ data_engine/gui/workers.py | 72 ++ data_engine/main.py | 830 +----------------------- data_engine/run.py | 100 --- data_engine/sam_processor.py | 510 --------------- data_engine/setup.py | 136 ---- scripts/I want to work.md | 14 + third_party/sam2 | 1 + 22 files changed, 1335 insertions(+), 1881 deletions(-) create mode 100644 data_engine/.dockerignore create mode 100644 data_engine/Dockerfile delete mode 100644 data_engine/Makefile create mode 100644 data_engine/docker-compose.yml delete mode 100644 data_engine/example.py create mode 100644 data_engine/gui/README.md create mode 100644 data_engine/gui/__init__.py create mode 100644 data_engine/gui/center_panel.py create mode 100644 data_engine/gui/frame_viewer.py create mode 100644 data_engine/gui/left_panel.py create mode 100644 data_engine/gui/main_window.py create mode 100644 data_engine/gui/object_class_manager.py create mode 100644 data_engine/gui/right_panel.py create mode 100644 data_engine/gui/workers.py delete mode 100644 data_engine/run.py delete mode 100644 data_engine/sam_processor.py delete mode 100644 data_engine/setup.py create mode 100644 scripts/I want to work.md create mode 160000 third_party/sam2 diff --git a/.gitmodules b/.gitmodules index 8111c4f..9a53575 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,6 @@ [submodule "third_party/Depth-Anything-ONNX"] path = third_party/Depth-Anything-ONNX url = https://github.com/fabio-sim/Depth-Anything-ONNX.git +[submodule "third_party/sam2"] + path = third_party/sam2 + url = https://github.com/facebookresearch/sam2.git diff --git a/data_engine/.dockerignore b/data_engine/.dockerignore new file mode 100644 index 0000000..6aed783 --- /dev/null +++ b/data_engine/.dockerignore @@ -0,0 +1,118 @@ +# Docker ignore file for SAM2 Data Engine + +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# Virtual environments +venv/ +env/ +ENV/ +env.bak/ +venv.bak/ + +# Cache directories +cache/ +.cache/ +*.cache + +# IDE and editor files +.vscode/ +.idea/ +*.swp +*.swo +*~ +.DS_Store +Thumbs.db + +# Logs +*.log +logs/ + +# Test files +test_output/ +test_config/ +.pytest_cache/ +.coverage +htmlcov/ + +# Model files (large) +*.pt +*.pth +*.onnx +*.trt +models/ + +# Data directories +data/ +datasets/ +videos/ +exports/ +projects/ + +# Docker files (don't copy into container) +Dockerfile* +docker-compose*.yml +.dockerignore + +# Git +.git/ +.gitignore + +# Documentation +docs/ +*.md +!README.md + +# Temporary files +tmp/ +temp/ +.tmp/ + +# OS specific +.DS_Store +Thumbs.db +desktop.ini + +# Jupyter +.ipynb_checkpoints/ +*.ipynb + +# Environment files +.env +.env.local +.env.*.local + +# Large media files +*.mp4 +*.avi +*.mov +*.mkv +*.wmv +*.webm +*.flv + +# Archives +*.zip +*.tar.gz +*.rar +*.7z diff --git a/data_engine/Dockerfile b/data_engine/Dockerfile new file mode 100644 index 0000000..39e3310 --- /dev/null +++ b/data_engine/Dockerfile @@ -0,0 +1,39 @@ +# SAM2 Data Engine Dockerfile +FROM pytorch/pytorch:2.7.1-cuda12.6-cudnn9-runtime + +# Install system dependencies for GUI applications +RUN apt-get update && apt-get install -y \ + libgl1-mesa-glx \ + libglib2.0-0 \ + libxrender1 \ + libxrandr2 \ + libxss1 \ + libxcursor1 \ + libxcomposite1 \ + libasound2 \ + libxi6 \ + libxtst6 \ + libqt5gui5 \ + libqt5core5a \ + libqt5widgets5 \ + qt5-gtk-platformtheme \ + && rm -rf /var/lib/apt/lists/* + +# Set working directory +WORKDIR /app + +# Copy requirements first for better caching +COPY requirements.txt . + +# Install Python dependencies +RUN pip install --no-cache-dir -r requirements.txt + +# Copy the current directory contents +COPY . . + +# Set environment variables for GUI +ENV QT_X11_NO_MITSHM=1 +ENV DISPLAY=:0 + +# Run the main GUI application +CMD ["python", "main.py"] diff --git a/data_engine/Makefile b/data_engine/Makefile deleted file mode 100644 index 84224e9..0000000 --- a/data_engine/Makefile +++ /dev/null @@ -1,100 +0,0 @@ -# Makefile for SAM2 Data Engine - -.PHONY: install setup run clean test help - -# Default Python interpreter -PYTHON := python3 - -# Virtual environment name -VENV := venv - -help: ## Show this help message - @echo "SAM2 Data Engine - Available commands:" - @echo - @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf " \033[36m%-15s\033[0m %s\n", $$1, $$2}' - -install: ## Install requirements - $(PYTHON) -m pip install -r requirements.txt - -setup: ## Run full setup (install + download models) - $(PYTHON) setup.py - -run: ## Run the data engine application - $(PYTHON) run.py - -test: ## Run example/test script - $(PYTHON) example.py - -clean: ## Clean cache and temporary files - find . -type d -name "__pycache__" -exec rm -rf {} + - find . -type f -name "*.pyc" -delete - find . -type f -name "*.pyo" -delete - rm -rf test_output/ - rm -rf test_config/ - -venv: ## Create virtual environment - $(PYTHON) -m venv $(VENV) - @echo "Activate with: source $(VENV)/bin/activate" - -venv-install: venv ## Create venv and install requirements - $(VENV)/bin/pip install -r requirements.txt - -venv-run: ## Run application in virtual environment - $(VENV)/bin/python run.py - -dev-install: ## Install development dependencies - $(PYTHON) -m pip install -r requirements.txt - $(PYTHON) -m pip install black flake8 mypy - -format: ## Format code with black - black *.py - -lint: ## Lint code with flake8 - flake8 *.py - -type-check: ## Type check with mypy - mypy *.py --ignore-missing-imports - -check: format lint type-check ## Run all code quality checks - -# Docker commands (if needed) -docker-build: ## Build Docker image - docker build -t sam2-data-engine . - -docker-run: ## Run in Docker container - docker run -it --rm -v $(PWD):/app sam2-data-engine - -# Documentation -docs: ## Generate documentation - @echo "Documentation available in README.md" - @echo "For detailed usage, see: python example.py" - -# System info -info: ## Show system information - @echo "Python version:" - @$(PYTHON) --version - @echo - @echo "Pip packages:" - @$(PYTHON) -m pip list | grep -E "(torch|opencv|PySide6|ultralytics|numpy|Pillow)" - @echo - @echo "CUDA availability:" - @$(PYTHON) -c "import torch; print('CUDA available:', torch.cuda.is_available())" 2>/dev/null || echo "PyTorch not installed" - -# Quick start -quickstart: ## Quick start guide - @echo "SAM2 Data Engine - Quick Start" - @echo "==============================" - @echo - @echo "1. Install dependencies:" - @echo " make install" - @echo - @echo "2. Run setup (download models):" - @echo " make setup" - @echo - @echo "3. Launch application:" - @echo " make run" - @echo - @echo "4. For testing without GUI:" - @echo " make test" - @echo - @echo "For more commands: make help" diff --git a/data_engine/README.md b/data_engine/README.md index 092d3bc..cf51d78 100644 --- a/data_engine/README.md +++ b/data_engine/README.md @@ -26,6 +26,8 @@ An automatic data engine GUI application that uses visual prompts to interact wi ## Installation +### Option 1: Local Installation + 1. **Clone or navigate to the data_engine directory**: ```bash cd /path/to/hydrus-software-stack/data_engine @@ -46,6 +48,30 @@ python setup.py python main.py ``` +### Option 2: Docker Installation (Recommended) + +1. **Setup X11 for GUI support**: +```bash +make docker-setup +``` + +2. **Build and run with Docker**: +```bash +make docker-build +make docker-run +``` + +3. **Alternative Docker commands**: +```bash +# Interactive shell +make docker-shell + +# Run tests +make docker-test +``` + +For detailed Docker setup, see [DOCKER.md](DOCKER.md). + ## Usage ### 1. Load Video diff --git a/data_engine/docker-compose.yml b/data_engine/docker-compose.yml new file mode 100644 index 0000000..0a03bd2 --- /dev/null +++ b/data_engine/docker-compose.yml @@ -0,0 +1,69 @@ +version: '3.8' + +services: + sam2-data-engine: + build: + context: . + dockerfile: Dockerfile + image: sam2-data-engine:latest + container_name: sam2_data_engine + + # GPU support + deploy: + resources: + reservations: + devices: + - driver: nvidia + count: all + capabilities: [gpu] + + # X11 Display support + environment: + - DISPLAY=${DISPLAY:-:0.0} + - QT_X11_NO_MITSHM=1 + - QT_QPA_PLATFORM=xcb + - XAUTHORITY=/tmp/.docker.xauth + - NVIDIA_VISIBLE_DEVICES=all + - NVIDIA_DRIVER_CAPABILITIES=all + + # Mount X11 socket and auth + volumes: + - /tmp/.X11-unix:/tmp/.X11-unix:rw + - /tmp/.docker.xauth:/tmp/.docker.xauth:rw + - ./data:/app/data:rw + - ./cache:/app/cache:rw + - ./projects:/app/projects:rw + - ./exports:/app/exports:rw + - ./videos:/app/videos:ro # Mount your video files here + + # Network mode for X11 + network_mode: host + + # Security options + security_opt: + - seccomp:unconfined + + # Additional privileges for GPU access + privileged: false + + # IPC mode for shared memory + ipc: host + + # Restart policy + restart: unless-stopped + + + +# Networks (optional - using host network for X11) +networks: + default: + driver: bridge + +# Volumes for persistent data +volumes: + sam2_cache: + driver: local + sam2_projects: + driver: local + sam2_exports: + driver: local diff --git a/data_engine/example.py b/data_engine/example.py deleted file mode 100644 index 23d9381..0000000 --- a/data_engine/example.py +++ /dev/null @@ -1,208 +0,0 @@ -#!/usr/bin/env python3 -""" -Example script demonstrating SAM2 Data Engine features -""" - -import sys -from pathlib import Path - -import numpy as np - -# Add data_engine to path -sys.path.insert(0, str(Path(__file__).parent)) - - -def create_sample_data(): - """Create some sample data for demonstration""" - print("Creating sample data...") - - # Create a simple test image - test_image = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8) - - # Add some shapes for segmentation - import cv2 - - # Draw a circle - cv2.circle(test_image, (200, 200), 50, (255, 0, 0), -1) - - # Draw a rectangle - cv2.rectangle(test_image, (400, 150), (500, 250), (0, 255, 0), -1) - - # Draw a triangle - points = np.array([[300, 350], [350, 300], [400, 350]], np.int32) - cv2.fillPoly(test_image, [points], (0, 0, 255)) - - return test_image - - -def demo_sam_processor(): - """Demonstrate SAM processor functionality""" - print("Testing SAM processor...") - - try: - from sam_processor import SAM2Processor - - # Initialize processor - processor = SAM2Processor() - - if not processor.is_loaded: - print("⚠ SAM model not loaded - this is expected without dependencies") - return False - - # Test with sample image - test_image = create_sample_data() - - # Test point segmentation - points = np.array([[200, 200], [400, 200]]) # Points in the shapes - labels = np.array([1, 1]) # Both positive - - result = processor.segment_with_points(test_image, points, labels) - - if result["success"]: - print("✓ SAM segmentation successful") - else: - print(f"✗ SAM segmentation failed: {result.get('error', 'Unknown error')}") - - return True - - except ImportError as e: - print(f"⚠ SAM processor import failed: {e}") - return False - - -def demo_utils(): - """Demonstrate utility functions""" - print("Testing utility functions...") - - try: - from utils import create_directory_structure, mask_to_polygon, polygon_to_mask - - # Test mask to polygon conversion - test_mask = np.zeros((100, 100), dtype=np.uint8) - test_mask[30:70, 30:70] = 255 # Square mask - - polygon = mask_to_polygon(test_mask) - print(f"✓ Converted mask to polygon with {len(polygon)//2} points") - - # Test polygon to mask conversion - reconstructed_mask = polygon_to_mask(polygon, 100, 100) - print(f"✓ Reconstructed mask shape: {reconstructed_mask.shape}") - - # Test directory structure creation - test_dir = Path(__file__).parent / "test_output" - directories = create_directory_structure(str(test_dir)) - print(f"✓ Created {len(directories)} directories") - - # Cleanup test directory - import shutil - - if test_dir.exists(): - shutil.rmtree(test_dir) - - return True - - except ImportError as e: - print(f"⚠ Utils import failed: {e}") - return False - except Exception as e: - print(f"✗ Utils test failed: {e}") - return False - - -def demo_config(): - """Demonstrate configuration management""" - print("Testing configuration...") - - try: - from config import ConfigManager - - # Create test config manager - test_config_dir = Path(__file__).parent / "test_config" - config_manager = ConfigManager(str(test_config_dir)) - - # Test configuration access - config = config_manager.config - print(f"✓ Loaded config with SAM model: {config.sam.model_name}") - - # Test configuration updates - config_manager.update_sam_config(model_name="sam2_l.pt") - print("✓ Updated SAM configuration") - - # Test project management - test_project_data = { - "video_path": "/test/video.mp4", - "annotations": {"frame_1": ["object_1"]}, - "classes": {0: "test_class"}, - } - - config_manager.save_project("test_project", test_project_data) - loaded_project = config_manager.load_project("test_project") - - if loaded_project: - print("✓ Project save/load successful") - else: - print("✗ Project save/load failed") - - # Cleanup test config - import shutil - - if test_config_dir.exists(): - shutil.rmtree(test_config_dir) - - return True - - except ImportError as e: - print(f"⚠ Config import failed: {e}") - return False - except Exception as e: - print(f"✗ Config test failed: {e}") - return False - - -def main(): - """Run all demonstrations""" - print("SAM2 Data Engine - Example and Test Script") - print("=" * 50) - - tests = [ - ("Utility Functions", demo_utils), - ("Configuration Management", demo_config), - ("SAM Processor", demo_sam_processor), - ] - - passed = 0 - total = len(tests) - - for test_name, test_func in tests: - print(f"\n--- {test_name} ---") - try: - if test_func(): - passed += 1 - print(f"✓ {test_name} passed") - else: - print(f"⚠ {test_name} completed with warnings") - except Exception as e: - print(f"✗ {test_name} failed: {e}") - - print(f"\n" + "=" * 50) - print(f"Tests completed: {passed}/{total} passed") - - if passed == total: - print("✓ All tests passed! The Data Engine should work correctly.") - elif passed > 0: - print( - "⚠ Some tests passed. Install missing dependencies for full functionality." - ) - else: - print("✗ Most tests failed. Please install dependencies and check setup.") - - print("\nTo install dependencies:") - print("pip install -r requirements.txt") - print("\nTo run the full application:") - print("python run.py") - - return 0 if passed > 0 else 1 - - -if __name__ == "__main__": - sys.exit(main()) diff --git a/data_engine/gui/README.md b/data_engine/gui/README.md new file mode 100644 index 0000000..3cb8318 --- /dev/null +++ b/data_engine/gui/README.md @@ -0,0 +1,75 @@ +# GUI Module + +This directory contains the modularized GUI components for the SAM2 Data Engine application. + +## Structure + +- `__init__.py` - Module initialization and exports +- `main_window.py` - Main application window and core logic +- `frame_viewer.py` - Interactive frame viewer widget with point selection +- `object_class_manager.py` - Widget for managing object classes +- `left_panel.py` - Left control panel with video loading, navigation, and SAM controls +- `right_panel.py` - Right panel with class management and annotations display +- `center_panel.py` - Center panel wrapper for the frame viewer +- `workers.py` - Background worker threads for video processing and SAM operations + +## Components Overview + +### DataEngineMainWindow +The main application window that orchestrates all other components. Handles: +- Video loading and frame caching +- SAM model initialization +- Annotation management +- YOLO dataset export + +### FrameViewer +Custom widget for displaying video frames with interactive point selection: +- Click-based point annotation (positive/negative) +- Visual feedback for selected points +- Frame scaling and coordinate mapping + +### ObjectClassManager +Widget for managing object classes in the dataset: +- Add/remove classes +- Class selection for annotation +- Dynamic class ID assignment + +### Control Panels +- **LeftControlPanel**: Video controls, navigation, SAM settings, export +- **RightPanel**: Class management, annotations list, statistics +- **CenterPanel**: Simple wrapper for the frame viewer + +### Workers +- **VideoProcessor**: Background thread for frame extraction and caching +- **SAMProcessor**: Background worker for SAM2 segmentation processing + +## Usage + +```python +from gui import DataEngineMainWindow +from PySide6.QtWidgets import QApplication +import sys + +app = QApplication(sys.argv) +window = DataEngineMainWindow() +window.show() +sys.exit(app.exec()) +``` + +## Dependencies + +- PySide6 (Qt GUI framework) +- OpenCV (cv2) for image processing +- NumPy for array operations +- PyTorch for tensor operations +- Ultralytics SAM for segmentation +- pathlib for path handling + +## Architecture + +The GUI follows a modular design pattern where: +1. Each major UI component is in its own file +2. The main window coordinates between components +3. Worker threads handle heavy processing +4. Signal/slot connections provide component communication +5. Clean separation between UI and business logic diff --git a/data_engine/gui/__init__.py b/data_engine/gui/__init__.py new file mode 100644 index 0000000..fb9c470 --- /dev/null +++ b/data_engine/gui/__init__.py @@ -0,0 +1,23 @@ +""" +GUI module for SAM2 Data Engine +Contains modularized GUI components +""" + +from .center_panel import CenterPanel +from .frame_viewer import FrameViewer +from .left_panel import LeftControlPanel +from .main_window import DataEngineMainWindow +from .object_class_manager import ObjectClassManager +from .right_panel import RightPanel +from .workers import SAMProcessor, VideoProcessor + +__all__ = [ + "DataEngineMainWindow", + "FrameViewer", + "ObjectClassManager", + "LeftControlPanel", + "RightPanel", + "CenterPanel", + "VideoProcessor", + "SAMProcessor", +] diff --git a/data_engine/gui/center_panel.py b/data_engine/gui/center_panel.py new file mode 100644 index 0000000..a196ff5 --- /dev/null +++ b/data_engine/gui/center_panel.py @@ -0,0 +1,25 @@ +""" +Center panel containing the frame viewer +""" + +from PySide6.QtWidgets import QVBoxLayout, QWidget + +from .frame_viewer import FrameViewer + + +class CenterPanel(QWidget): + """Center panel for frame viewing""" + + def __init__(self, parent=None): + super().__init__(parent) + self.setup_ui() + + def setup_ui(self): + """Setup the center panel UI""" + layout = QVBoxLayout() + + # Frame viewer + self.frame_viewer = FrameViewer() + + layout.addWidget(self.frame_viewer) + self.setLayout(layout) diff --git a/data_engine/gui/frame_viewer.py b/data_engine/gui/frame_viewer.py new file mode 100644 index 0000000..60df08b --- /dev/null +++ b/data_engine/gui/frame_viewer.py @@ -0,0 +1,94 @@ +""" +Frame viewer widget for displaying video frames with interactive point selection +""" + +import cv2 +import numpy as np +from PySide6.QtCore import Signal +from PySide6.QtGui import QImage, QPixmap +from PySide6.QtWidgets import QLabel + + +class FrameViewer(QLabel): + """Custom QLabel for displaying frames with click interaction""" + + point_clicked = Signal( + int, int, int + ) # x, y, label (1 for positive, 0 for negative) + + def __init__(self): + super().__init__() + self.setMinimumSize(640, 480) + self.setStyleSheet("border: 2px solid gray;") + self.setScaledContents(True) + self.current_frame = None + self.scale_factor = 1.0 + self.click_mode = 1 # 1 for positive, 0 for negative + self.points = [] # List of (x, y, label) tuples + + def set_frame(self, frame: np.ndarray): + """Set the current frame to display""" + self.current_frame = frame.copy() + self.update_display() + + def set_click_mode(self, mode: int): + """Set click mode: 1 for positive points, 0 for negative points""" + self.click_mode = mode + + def add_point(self, x: int, y: int, label: int): + """Add a point to the current frame""" + self.points.append((x, y, label)) + self.update_display() + + def clear_points(self): + """Clear all points""" + self.points.clear() + self.update_display() + + def update_display(self): + """Update the display with current frame and points""" + if self.current_frame is None: + return + + display_frame = self.current_frame.copy() + + # Draw points + for x, y, label in self.points: + color = ( + (0, 255, 0) if label == 1 else (0, 0, 255) + ) # Green for positive, Red for negative + cv2.circle(display_frame, (x, y), 5, color, -1) + cv2.circle(display_frame, (x, y), 7, (255, 255, 255), 2) + + # Convert to QPixmap + height, width, channel = display_frame.shape + bytes_per_line = 3 * width + q_image = QImage( + display_frame.data, width, height, bytes_per_line, QImage.Format_RGB888 + ).rgbSwapped() + pixmap = QPixmap.fromImage(q_image) + self.setPixmap(pixmap) + + def mousePressEvent(self, event): + """Handle mouse click events""" + if self.current_frame is None: + return + + # Get click position relative to the actual image + widget_size = self.size() + pixmap_size = self.pixmap().size() if self.pixmap() else widget_size + + # Calculate scale factors + scale_x = self.current_frame.shape[1] / pixmap_size.width() + scale_y = self.current_frame.shape[0] / pixmap_size.height() + + # Convert widget coordinates to image coordinates + x = int(event.position().x() * scale_x) + y = int(event.position().y() * scale_y) + + # Ensure coordinates are within bounds + x = max(0, min(x, self.current_frame.shape[1] - 1)) + y = max(0, min(y, self.current_frame.shape[0] - 1)) + + self.add_point(x, y, self.click_mode) + self.point_clicked.emit(x, y, self.click_mode) diff --git a/data_engine/gui/left_panel.py b/data_engine/gui/left_panel.py new file mode 100644 index 0000000..8c2e315 --- /dev/null +++ b/data_engine/gui/left_panel.py @@ -0,0 +1,149 @@ +""" +Left control panel for video loading, navigation, and SAM controls +""" + +from pathlib import Path + +from PySide6.QtCore import Qt +from PySide6.QtWidgets import ( + QGroupBox, + QHBoxLayout, + QLabel, + QPushButton, + QSlider, + QSpinBox, + QVBoxLayout, + QWidget, +) + + +class LeftControlPanel(QWidget): + """Left panel containing video loading, navigation, and SAM controls""" + + def __init__(self, parent=None): + super().__init__(parent) + self.setup_ui() + + def setup_ui(self): + """Setup the left panel UI""" + layout = QVBoxLayout() + + # Video loading group + video_group = self.create_video_group() + + # Frame navigation group + nav_group = self.create_navigation_group() + + # SAM controls group + sam_group = self.create_sam_group() + + # Export group + export_group = self.create_export_group() + + # Add all groups to layout + layout.addWidget(video_group) + layout.addWidget(nav_group) + layout.addWidget(sam_group) + layout.addWidget(export_group) + layout.addStretch() + + self.setLayout(layout) + + def create_video_group(self) -> QGroupBox: + """Create video loading group""" + video_group = QGroupBox("Video Loading") + video_layout = QVBoxLayout() + + self.load_video_btn = QPushButton("Load Video") + self.video_path_label = QLabel("No video loaded") + self.video_path_label.setWordWrap(True) + + self.output_dir_btn = QPushButton("Set Output Directory") + self.output_dir_label = QLabel("No output directory set") + self.output_dir_label.setWordWrap(True) + + video_layout.addWidget(self.load_video_btn) + video_layout.addWidget(self.video_path_label) + video_layout.addWidget(self.output_dir_btn) + video_layout.addWidget(self.output_dir_label) + video_group.setLayout(video_layout) + + return video_group + + def create_navigation_group(self) -> QGroupBox: + """Create frame navigation group""" + nav_group = QGroupBox("Frame Navigation") + nav_layout = QVBoxLayout() + + # Frame slider + self.frame_slider = QSlider(Qt.Horizontal) + + # Frame controls + frame_controls = QHBoxLayout() + self.prev_btn = QPushButton("◀ Prev") + self.frame_spinbox = QSpinBox() + self.next_btn = QPushButton("Next ▶") + + frame_controls.addWidget(self.prev_btn) + frame_controls.addWidget(self.frame_spinbox) + frame_controls.addWidget(self.next_btn) + + nav_layout.addWidget(QLabel("Frame:")) + nav_layout.addWidget(self.frame_slider) + nav_layout.addLayout(frame_controls) + nav_group.setLayout(nav_layout) + + return nav_group + + def create_sam_group(self) -> QGroupBox: + """Create SAM controls group""" + sam_group = QGroupBox("SAM2 Controls") + sam_layout = QVBoxLayout() + + # Point selection mode + point_mode_layout = QHBoxLayout() + self.positive_point_btn = QPushButton("Positive Point") + self.positive_point_btn.setCheckable(True) + self.positive_point_btn.setChecked(True) + + self.negative_point_btn = QPushButton("Negative Point") + self.negative_point_btn.setCheckable(True) + + point_mode_layout.addWidget(self.positive_point_btn) + point_mode_layout.addWidget(self.negative_point_btn) + + # SAM action buttons + self.clear_points_btn = QPushButton("Clear Points") + self.segment_btn = QPushButton("Segment Object") + + # Propagation controls + prop_layout = QHBoxLayout() + self.propagate_forward_btn = QPushButton("Propagate Forward") + self.propagate_backward_btn = QPushButton("Propagate Backward") + + prop_layout.addWidget(self.propagate_forward_btn) + prop_layout.addWidget(self.propagate_backward_btn) + + sam_layout.addLayout(point_mode_layout) + sam_layout.addWidget(self.clear_points_btn) + sam_layout.addWidget(self.segment_btn) + sam_layout.addLayout(prop_layout) + sam_group.setLayout(sam_layout) + + return sam_group + + def create_export_group(self) -> QGroupBox: + """Create export group""" + from PySide6.QtWidgets import QProgressBar + + export_group = QGroupBox("Export") + export_layout = QVBoxLayout() + + self.export_yolo_btn = QPushButton("Export YOLO Dataset") + self.progress_bar = QProgressBar() + + export_layout.addWidget(self.export_yolo_btn) + export_layout.addWidget(self.progress_bar) + export_group.setLayout(export_layout) + + return export_group diff --git a/data_engine/gui/main_window.py b/data_engine/gui/main_window.py new file mode 100644 index 0000000..999b9c5 --- /dev/null +++ b/data_engine/gui/main_window.py @@ -0,0 +1,465 @@ +""" +Main window for the SAM2 Data Engine application +""" + +import json +from pathlib import Path +from typing import Dict, List, Optional, Tuple + +import cv2 +import numpy as np +import torch +from PySide6.QtCore import Qt, QThreadPool +from PySide6.QtWidgets import ( + QApplication, + QFileDialog, + QHBoxLayout, + QMainWindow, + QMessageBox, + QSplitter, + QWidget, +) + +try: + from ultralytics import SAM +except ImportError: + print("Warning: ultralytics not installed. Limited functionality.") + SAM = None + +# Import local modules +try: + from config import get_config_manager + from sam_processor import SAM2Processor + from utils import create_directory_structure, export_statistics +except ImportError as e: + print(f"Warning: Could not import local modules: {e}") + SAM2Processor = None + get_config_manager = None + create_directory_structure = None + export_statistics = None + +from .center_panel import CenterPanel +from .frame_viewer import FrameViewer +from .left_panel import LeftControlPanel +from .right_panel import RightPanel +from .workers import SAMProcessor, VideoProcessor + + +class DataEngineMainWindow(QMainWindow): + """Main window for the Data Engine application""" + + def __init__(self): + super().__init__() + self.setWindowTitle("SAM2 Data Engine - YOLO Dataset Generator") + self.setGeometry(100, 100, 1400, 900) + + # Initialize variables + self.video_path = None + self.output_dir = None + self.frames = [] + self.current_frame_idx = 0 + self.sam_model = None + self.frame_cache = {} + self.masks_cache = {} + self.annotations = {} # frame_idx: [annotations] + + # Thread pool for SAM processing + self.thread_pool = QThreadPool() + + self.setup_ui() + self.connect_signals() + self.load_sam_model() + + def setup_ui(self): + """Setup the user interface""" + central_widget = QWidget() + self.setCentralWidget(central_widget) + + # Main layout + main_layout = QHBoxLayout() + + # Create panels + self.left_panel = LeftControlPanel() + self.frame_viewer = FrameViewer() + self.right_panel = RightPanel() + + # Create splitter for resizable panels + splitter = QSplitter(Qt.Horizontal) + splitter.addWidget(self.left_panel) + splitter.addWidget(self.frame_viewer) + splitter.addWidget(self.right_panel) + splitter.setSizes([300, 700, 300]) + + main_layout.addWidget(splitter) + central_widget.setLayout(main_layout) + + def connect_signals(self): + """Connect signals between components""" + # Left panel signals + self.left_panel.load_video_btn.clicked.connect(self.load_video) + self.left_panel.output_dir_btn.clicked.connect(self.set_output_directory) + + # Frame navigation + self.left_panel.frame_slider.valueChanged.connect(self.on_frame_changed) + self.left_panel.frame_spinbox.valueChanged.connect( + self.on_frame_spinbox_changed + ) + self.left_panel.prev_btn.clicked.connect(self.prev_frame) + self.left_panel.next_btn.clicked.connect(self.next_frame) + + # SAM controls + self.left_panel.positive_point_btn.clicked.connect( + lambda: self.set_point_mode(1) + ) + self.left_panel.negative_point_btn.clicked.connect( + lambda: self.set_point_mode(0) + ) + self.left_panel.clear_points_btn.clicked.connect(self.clear_points) + self.left_panel.segment_btn.clicked.connect(self.segment_current_frame) + self.left_panel.propagate_forward_btn.clicked.connect(self.propagate_forward) + self.left_panel.propagate_backward_btn.clicked.connect(self.propagate_backward) + + # Export + self.left_panel.export_yolo_btn.clicked.connect(self.export_yolo_dataset) + + # Frame viewer signals + self.frame_viewer.point_clicked.connect(self.on_point_clicked) + + # Right panel signals + self.right_panel.remove_annotation_btn.clicked.connect(self.remove_annotation) + + def load_sam_model(self): + """Load the SAM2 model""" + try: + self.sam_model = SAM("sam2_b.pt") # Use SAM2 base model + print("SAM2 model loaded successfully") + except Exception as e: + QMessageBox.warning( + self, "Model Loading Error", f"Failed to load SAM2 model: {e}" + ) + + def load_video(self): + """Load a video file""" + file_path, _ = QFileDialog.getOpenFileName( + self, + "Select Video File", + "", + "Video Files (*.mp4 *.avi *.mov *.mkv *.wmv);;All Files (*)", + ) + + if file_path: + self.video_path = file_path + self.left_panel.video_path_label.setText(f"Video: {Path(file_path).name}") + self.load_video_frames() + + def set_output_directory(self): + """Set the output directory for the dataset""" + dir_path = QFileDialog.getExistingDirectory(self, "Select Output Directory") + + if dir_path: + self.output_dir = dir_path + self.left_panel.output_dir_label.setText(f"Output: {Path(dir_path).name}") + + def load_video_frames(self): + """Load frames from the video""" + if not self.video_path: + return + + try: + cap = cv2.VideoCapture(self.video_path) + total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) + + # Setup frame navigation + self.left_panel.frame_slider.setMaximum(total_frames - 1) + self.left_panel.frame_spinbox.setMaximum(total_frames - 1) + + # Cache first frame for immediate display + cap.set(cv2.CAP_PROP_POS_FRAMES, 0) + ret, frame = cap.read() + if ret: + self.frame_cache[0] = frame + self.frame_viewer.set_frame(frame) + + cap.release() + + # Start background frame caching + if self.output_dir: + self.cache_frames_async() + + self.update_stats() + + except Exception as e: + QMessageBox.critical(self, "Error", f"Failed to load video: {e}") + + def cache_frames_async(self): + """Cache frames asynchronously""" + cache_dir = Path(self.output_dir) / "cache" / "frames" + cache_dir.mkdir(parents=True, exist_ok=True) + + # Process video frames in background + self.video_processor = VideoProcessor(self.video_path, str(cache_dir)) + self.video_processor.frame_processed.connect(self.on_frame_cached) + self.video_processor.progress_updated.connect( + self.left_panel.progress_bar.setValue + ) + self.video_processor.start() + + def on_frame_cached(self, frame_idx: int, frame: np.ndarray): + """Handle cached frame""" + self.frame_cache[frame_idx] = frame + + def on_frame_changed(self, frame_idx: int): + """Handle frame slider change""" + self.current_frame_idx = frame_idx + self.left_panel.frame_spinbox.setValue(frame_idx) + self.load_current_frame() + self.update_annotations_display() + + def on_frame_spinbox_changed(self, frame_idx: int): + """Handle frame spinbox change""" + self.left_panel.frame_slider.setValue(frame_idx) + + def load_current_frame(self): + """Load and display the current frame""" + if self.current_frame_idx in self.frame_cache: + frame = self.frame_cache[self.current_frame_idx] + self.frame_viewer.set_frame(frame) + else: + # Load frame from video if not cached + self.load_frame_from_video(self.current_frame_idx) + + def load_frame_from_video(self, frame_idx: int): + """Load a specific frame from video""" + if not self.video_path: + return + + try: + cap = cv2.VideoCapture(self.video_path) + cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx) + ret, frame = cap.read() + cap.release() + + if ret: + self.frame_cache[frame_idx] = frame + self.frame_viewer.set_frame(frame) + except Exception as e: + print(f"Error loading frame {frame_idx}: {e}") + + def prev_frame(self): + """Go to previous frame""" + if self.current_frame_idx > 0: + self.left_panel.frame_slider.setValue(self.current_frame_idx - 1) + + def next_frame(self): + """Go to next frame""" + max_frame = self.left_panel.frame_slider.maximum() + if self.current_frame_idx < max_frame: + self.left_panel.frame_slider.setValue(self.current_frame_idx + 1) + + def set_point_mode(self, mode: int): + """Set point selection mode""" + self.frame_viewer.set_click_mode(mode) + + # Update button states + self.left_panel.positive_point_btn.setChecked(mode == 1) + self.left_panel.negative_point_btn.setChecked(mode == 0) + + def clear_points(self): + """Clear all points on current frame""" + self.frame_viewer.clear_points() + + def on_point_clicked(self, x: int, y: int, label: int): + """Handle point click on frame""" + print(f"Point clicked: ({x}, {y}), label: {label}") + + def segment_current_frame(self): + """Segment object in current frame using SAM2""" + if not self.sam_model or self.current_frame_idx not in self.frame_cache: + QMessageBox.warning(self, "Error", "No model loaded or frame not available") + return + + if not self.frame_viewer.points: + QMessageBox.warning(self, "Error", "Please add at least one point") + return + + current_class_id = self.right_panel.class_manager.get_current_class_id() + if current_class_id is None: + QMessageBox.warning(self, "Error", "Please select a class") + return + + # Prepare points and labels for SAM + points = np.array([[x, y] for x, y, _ in self.frame_viewer.points]) + labels = np.array([label for _, _, label in self.frame_viewer.points]) + + frame = self.frame_cache[self.current_frame_idx] + + # Run SAM segmentation + try: + results = self.sam_model(frame, points=points, labels=labels) + + if results and len(results) > 0: + result = results[0] + if hasattr(result, "masks") and result.masks is not None: + # Get the best mask + mask = result.masks.data[0].cpu().numpy() + + # Store annotation + self.store_annotation( + self.current_frame_idx, mask, current_class_id + ) + self.update_annotations_display() + + # Cache mask + self.cache_mask(self.current_frame_idx, mask, current_class_id) + + except Exception as e: + QMessageBox.critical(self, "Segmentation Error", f"Failed to segment: {e}") + + def store_annotation(self, frame_idx: int, mask: np.ndarray, class_id: int): + """Store annotation for a frame""" + if frame_idx not in self.annotations: + self.annotations[frame_idx] = [] + + annotation = { + "mask": mask, + "class_id": class_id, + "class_name": self.right_panel.class_manager.classes.get( + class_id, "unknown" + ), + } + + self.annotations[frame_idx].append(annotation) + + def cache_mask(self, frame_idx: int, mask: np.ndarray, class_id: int): + """Cache mask to disk""" + if not self.output_dir: + return + + cache_dir = Path(self.output_dir) / "cache" / "masks" + cache_dir.mkdir(parents=True, exist_ok=True) + + mask_path = cache_dir / f"frame_{frame_idx:06d}_class_{class_id}.pt" + torch.save(torch.from_numpy(mask), mask_path) + + def propagate_forward(self): + """Propagate segmentation forward""" + # TODO: Implement SAM2 video tracking for forward propagation + QMessageBox.information(self, "Info", "Forward propagation not yet implemented") + + def propagate_backward(self): + """Propagate segmentation backward""" + # TODO: Implement SAM2 video tracking for backward propagation + QMessageBox.information( + self, "Info", "Backward propagation not yet implemented" + ) + + def update_annotations_display(self): + """Update the annotations list for current frame""" + self.right_panel.annotations_list.clear() + + if self.current_frame_idx in self.annotations: + for i, annotation in enumerate(self.annotations[self.current_frame_idx]): + class_name = annotation["class_name"] + item_text = f"Object {i}: {class_name}" + self.right_panel.annotations_list.addItem(item_text) + + def remove_annotation(self): + """Remove selected annotation""" + current_item = self.right_panel.annotations_list.currentItem() + if current_item and self.current_frame_idx in self.annotations: + row = self.right_panel.annotations_list.row(current_item) + if 0 <= row < len(self.annotations[self.current_frame_idx]): + del self.annotations[self.current_frame_idx][row] + self.update_annotations_display() + + def export_yolo_dataset(self): + """Export annotations in YOLO format""" + if not self.output_dir: + QMessageBox.warning(self, "Error", "Please set output directory first") + return + + if not self.annotations: + QMessageBox.warning(self, "Error", "No annotations to export") + return + + try: + self.create_yolo_dataset() + QMessageBox.information( + self, "Success", "YOLO dataset exported successfully" + ) + except Exception as e: + QMessageBox.critical(self, "Export Error", f"Failed to export dataset: {e}") + + def create_yolo_dataset(self): + """Create YOLO format dataset""" + dataset_dir = Path(self.output_dir) / "yolo_dataset" + images_dir = dataset_dir / "images" + labels_dir = dataset_dir / "labels" + + images_dir.mkdir(parents=True, exist_ok=True) + labels_dir.mkdir(parents=True, exist_ok=True) + + # Create classes.txt + classes_file = dataset_dir / "classes.txt" + with open(classes_file, "w") as f: + classes = self.right_panel.class_manager.get_classes() + for class_id in sorted(classes.keys()): + f.write(f"{classes[class_id]}\n") + + # Export annotated frames + for frame_idx, annotations in self.annotations.items(): + if frame_idx not in self.frame_cache: + continue + + # Save image + frame = self.frame_cache[frame_idx] + image_path = images_dir / f"frame_{frame_idx:06d}.jpg" + cv2.imwrite(str(image_path), frame) + + # Save labels + label_path = labels_dir / f"frame_{frame_idx:06d}.txt" + with open(label_path, "w") as f: + for annotation in annotations: + # Convert mask to YOLO segmentation format + mask = annotation["mask"] + class_id = annotation["class_id"] + + # Find contours from mask + mask_uint8 = (mask * 255).astype(np.uint8) + contours, _ = cv2.findContours( + mask_uint8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE + ) + + if contours: + # Use the largest contour + largest_contour = max(contours, key=cv2.contourArea) + + # Normalize coordinates + h, w = frame.shape[:2] + normalized_contour = [] + + for point in largest_contour: + x, y = point[0] + normalized_contour.extend([x / w, y / h]) + + # Write YOLO segmentation line + if len(normalized_contour) >= 6: # At least 3 points + line = f"{class_id} " + " ".join( + [f"{coord:.6f}" for coord in normalized_contour] + ) + f.write(line + "\n") + + def update_stats(self): + """Update statistics display""" + total_frames = len(self.frame_cache) + annotated_frames = len(self.annotations) + total_annotations = sum(len(anns) for anns in self.annotations.values()) + + stats_text = f""" +Total Frames: {total_frames} +Annotated Frames: {annotated_frames} +Total Annotations: {total_annotations} +Current Frame: {self.current_frame_idx} + """ + + self.right_panel.stats_label.setText(stats_text.strip()) diff --git a/data_engine/gui/object_class_manager.py b/data_engine/gui/object_class_manager.py new file mode 100644 index 0000000..f44ce13 --- /dev/null +++ b/data_engine/gui/object_class_manager.py @@ -0,0 +1,88 @@ +""" +Object class manager widget for managing object classes in the dataset +""" + +from typing import Dict, Optional + +from PySide6.QtWidgets import ( + QHBoxLayout, + QLabel, + QLineEdit, + QListWidget, + QPushButton, + QVBoxLayout, + QWidget, +) + + +class ObjectClassManager(QWidget): + """Widget for managing object classes""" + + def __init__(self): + super().__init__() + self.classes = {} # id: name mapping + self.setup_ui() + + def setup_ui(self): + layout = QVBoxLayout() + + # Add class controls + add_layout = QHBoxLayout() + self.class_name_input = QLineEdit() + self.class_name_input.setPlaceholderText("Enter class name") + add_button = QPushButton("Add Class") + add_button.clicked.connect(self.add_class) + + add_layout.addWidget(QLabel("Class Name:")) + add_layout.addWidget(self.class_name_input) + add_layout.addWidget(add_button) + + # Class list + self.class_list = QListWidget() + + # Remove class button + remove_button = QPushButton("Remove Selected") + remove_button.clicked.connect(self.remove_selected_class) + + layout.addLayout(add_layout) + layout.addWidget(QLabel("Classes:")) + layout.addWidget(self.class_list) + layout.addWidget(remove_button) + + self.setLayout(layout) + + def add_class(self): + """Add a new class""" + name = self.class_name_input.text().strip() + if name and name not in self.classes.values(): + class_id = len(self.classes) + self.classes[class_id] = name + self.class_list.addItem(f"{class_id}: {name}") + self.class_name_input.clear() + + def remove_selected_class(self): + """Remove selected class""" + current_item = self.class_list.currentItem() + if current_item: + # Parse class ID from item text + text = current_item.text() + class_id = int(text.split(":")[0]) + + # Remove from classes dict + if class_id in self.classes: + del self.classes[class_id] + + # Remove from list + self.class_list.takeItem(self.class_list.row(current_item)) + + def get_current_class_id(self) -> Optional[int]: + """Get currently selected class ID""" + current_item = self.class_list.currentItem() + if current_item: + text = current_item.text() + return int(text.split(":")[0]) + return None + + def get_classes(self) -> Dict[int, str]: + """Get all classes""" + return self.classes.copy() diff --git a/data_engine/gui/right_panel.py b/data_engine/gui/right_panel.py new file mode 100644 index 0000000..d275f08 --- /dev/null +++ b/data_engine/gui/right_panel.py @@ -0,0 +1,71 @@ +""" +Right panel for object class management and annotations display +""" + +from PySide6.QtWidgets import ( + QGroupBox, + QHBoxLayout, + QListWidget, + QPushButton, + QTextEdit, + QVBoxLayout, + QWidget, +) + +from .object_class_manager import ObjectClassManager + + +class RightPanel(QWidget): + """Right panel for classes and annotations""" + + def __init__(self, parent=None): + super().__init__(parent) + self.setup_ui() + + def setup_ui(self): + """Setup the right panel UI""" + layout = QVBoxLayout() + + # Object class manager + self.class_manager = ObjectClassManager() + + # Current annotations + annotations_group = self.create_annotations_group() + + # Statistics + stats_group = self.create_stats_group() + + layout.addWidget(self.class_manager) + layout.addWidget(annotations_group) + layout.addWidget(stats_group) + + self.setLayout(layout) + + def create_annotations_group(self) -> QGroupBox: + """Create annotations display group""" + annotations_group = QGroupBox("Current Frame Annotations") + annotations_layout = QVBoxLayout() + + self.annotations_list = QListWidget() + + self.remove_annotation_btn = QPushButton("Remove Selected Annotation") + + annotations_layout.addWidget(self.annotations_list) + annotations_layout.addWidget(self.remove_annotation_btn) + annotations_group.setLayout(annotations_layout) + + return annotations_group + + def create_stats_group(self) -> QGroupBox: + """Create statistics display group""" + stats_group = QGroupBox("Statistics") + stats_layout = QVBoxLayout() + + self.stats_label = QTextEdit() + self.stats_label.setMaximumHeight(150) + self.stats_label.setReadOnly(True) + + stats_layout.addWidget(self.stats_label) + stats_group.setLayout(stats_layout) + + return stats_group diff --git a/data_engine/gui/workers.py b/data_engine/gui/workers.py new file mode 100644 index 0000000..90c86e1 --- /dev/null +++ b/data_engine/gui/workers.py @@ -0,0 +1,72 @@ +""" +Background workers for video processing and SAM operations +""" + +from pathlib import Path + +import cv2 +import numpy as np +import torch +from PySide6.QtCore import QRunnable, QThread, Signal + + +class VideoProcessor(QThread): + """Thread for processing video frames and SAM2 operations""" + + frame_processed = Signal(int, np.ndarray) + progress_updated = Signal(int) + finished = Signal() + error_occurred = Signal(str) + + def __init__(self, video_path: str, output_dir: str): + super().__init__() + self.video_path = video_path + self.output_dir = output_dir + self.cache_dir = Path(output_dir) / "cache" + self.cache_dir.mkdir(exist_ok=True) + + def run(self): + try: + cap = cv2.VideoCapture(self.video_path) + total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) + + frame_idx = 0 + while True: + ret, frame = cap.read() + if not ret: + break + + # Cache frame + frame_path = self.cache_dir / f"frame_{frame_idx:06d}.jpg" + cv2.imwrite(str(frame_path), frame) + + self.frame_processed.emit(frame_idx, frame) + self.progress_updated.emit(int((frame_idx / total_frames) * 100)) + frame_idx += 1 + + cap.release() + self.finished.emit() + + except Exception as e: + self.error_occurred.emit(str(e)) + + +class SAMProcessor(QRunnable): + """Runnable for SAM2 segmentation processing""" + + def __init__(self, model, frame, points, labels, frame_idx, callback): + super().__init__() + self.model = model + self.frame = frame + self.points = points + self.labels = labels + self.frame_idx = frame_idx + self.callback = callback + + def run(self): + try: + # Process with SAM2 + results = self.model(self.frame, points=self.points, labels=self.labels) + self.callback(self.frame_idx, results) + except Exception as e: + print(f"SAM processing error: {e}") diff --git a/data_engine/main.py b/data_engine/main.py index 9fcf576..937ea2b 100644 --- a/data_engine/main.py +++ b/data_engine/main.py @@ -5,835 +5,11 @@ for generating YOLO training datasets using SAM2 segmentation. """ -import json -import os import sys -from pathlib import Path -from typing import Dict, List, Optional, Tuple -import cv2 -import numpy as np -import torch -from PIL import Image -from PySide6.QtCore import QRunnable, Qt, QThread, QThreadPool, QTimer, Signal -from PySide6.QtGui import QColor, QFont, QImage, QPainter, QPen, QPixmap -from PySide6.QtWidgets import ( - QApplication, - QCheckBox, - QComboBox, - QFileDialog, - QFrame, - QGroupBox, - QHBoxLayout, - QLabel, - QLineEdit, - QListWidget, - QListWidgetItem, - QMainWindow, - QMessageBox, - QProgressBar, - QPushButton, - QSlider, - QSpinBox, - QSplitter, - QTextEdit, - QVBoxLayout, - QWidget, -) - -try: - from ultralytics import SAM -except ImportError: - print("Warning: ultralytics not installed. Limited functionality.") - SAM = None - -# Import local modules -try: - from config import get_config_manager - from sam_processor import SAM2Processor - from utils import create_directory_structure, export_statistics -except ImportError as e: - print(f"Warning: Could not import local modules: {e}") - SAM2Processor = None - get_config_manager = None - create_directory_structure = None - export_statistics = None - - -class VideoProcessor(QThread): - """Thread for processing video frames and SAM2 operations""" - - frame_processed = Signal(int, np.ndarray) - progress_updated = Signal(int) - finished = Signal() - error_occurred = Signal(str) - - def __init__(self, video_path: str, output_dir: str): - super().__init__() - self.video_path = video_path - self.output_dir = output_dir - self.cache_dir = Path(output_dir) / "cache" - self.cache_dir.mkdir(exist_ok=True) - - def run(self): - try: - cap = cv2.VideoCapture(self.video_path) - total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) - - frame_idx = 0 - while True: - ret, frame = cap.read() - if not ret: - break - - # Cache frame - frame_path = self.cache_dir / f"frame_{frame_idx:06d}.jpg" - cv2.imwrite(str(frame_path), frame) - - self.frame_processed.emit(frame_idx, frame) - self.progress_updated.emit(int((frame_idx / total_frames) * 100)) - frame_idx += 1 - - cap.release() - self.finished.emit() - - except Exception as e: - self.error_occurred.emit(str(e)) - - -class SAMProcessor(QRunnable): - """Runnable for SAM2 segmentation processing""" - - def __init__(self, model, frame, points, labels, frame_idx, callback): - super().__init__() - self.model = model - self.frame = frame - self.points = points - self.labels = labels - self.frame_idx = frame_idx - self.callback = callback - - def run(self): - try: - # Process with SAM2 - results = self.model(self.frame, points=self.points, labels=self.labels) - self.callback(self.frame_idx, results) - except Exception as e: - print(f"SAM processing error: {e}") - - -class FrameViewer(QLabel): - """Custom QLabel for displaying frames with click interaction""" - - point_clicked = Signal( - int, int, int - ) # x, y, label (1 for positive, 0 for negative) - - def __init__(self): - super().__init__() - self.setMinimumSize(640, 480) - self.setStyleSheet("border: 2px solid gray;") - self.setScaledContents(True) - self.current_frame = None - self.scale_factor = 1.0 - self.click_mode = 1 # 1 for positive, 0 for negative - self.points = [] # List of (x, y, label) tuples - - def set_frame(self, frame: np.ndarray): - """Set the current frame to display""" - self.current_frame = frame.copy() - self.update_display() - - def set_click_mode(self, mode: int): - """Set click mode: 1 for positive points, 0 for negative points""" - self.click_mode = mode - - def add_point(self, x: int, y: int, label: int): - """Add a point to the current frame""" - self.points.append((x, y, label)) - self.update_display() - - def clear_points(self): - """Clear all points""" - self.points.clear() - self.update_display() - - def update_display(self): - """Update the display with current frame and points""" - if self.current_frame is None: - return - - display_frame = self.current_frame.copy() - - # Draw points - for x, y, label in self.points: - color = ( - (0, 255, 0) if label == 1 else (0, 0, 255) - ) # Green for positive, Red for negative - cv2.circle(display_frame, (x, y), 5, color, -1) - cv2.circle(display_frame, (x, y), 7, (255, 255, 255), 2) - - # Convert to QPixmap - height, width, channel = display_frame.shape - bytes_per_line = 3 * width - q_image = QImage( - display_frame.data, width, height, bytes_per_line, QImage.Format_RGB888 - ).rgbSwapped() - pixmap = QPixmap.fromImage(q_image) - self.setPixmap(pixmap) - - def mousePressEvent(self, event): - """Handle mouse click events""" - if self.current_frame is None: - return - - # Get click position relative to the actual image - widget_size = self.size() - pixmap_size = self.pixmap().size() if self.pixmap() else widget_size - - # Calculate scale factors - scale_x = self.current_frame.shape[1] / pixmap_size.width() - scale_y = self.current_frame.shape[0] / pixmap_size.height() - - # Convert widget coordinates to image coordinates - x = int(event.position().x() * scale_x) - y = int(event.position().y() * scale_y) - - # Ensure coordinates are within bounds - x = max(0, min(x, self.current_frame.shape[1] - 1)) - y = max(0, min(y, self.current_frame.shape[0] - 1)) - - self.add_point(x, y, self.click_mode) - self.point_clicked.emit(x, y, self.click_mode) - - -class ObjectClassManager(QWidget): - """Widget for managing object classes""" - - def __init__(self): - super().__init__() - self.classes = {} # id: name mapping - self.setup_ui() - - def setup_ui(self): - layout = QVBoxLayout() - - # Add class controls - add_layout = QHBoxLayout() - self.class_name_input = QLineEdit() - self.class_name_input.setPlaceholderText("Enter class name") - add_button = QPushButton("Add Class") - add_button.clicked.connect(self.add_class) - - add_layout.addWidget(QLabel("Class Name:")) - add_layout.addWidget(self.class_name_input) - add_layout.addWidget(add_button) - - # Class list - self.class_list = QListWidget() - - # Remove class button - remove_button = QPushButton("Remove Selected") - remove_button.clicked.connect(self.remove_selected_class) - - layout.addLayout(add_layout) - layout.addWidget(QLabel("Classes:")) - layout.addWidget(self.class_list) - layout.addWidget(remove_button) - - self.setLayout(layout) - - def add_class(self): - """Add a new class""" - name = self.class_name_input.text().strip() - if name and name not in self.classes.values(): - class_id = len(self.classes) - self.classes[class_id] = name - self.class_list.addItem(f"{class_id}: {name}") - self.class_name_input.clear() - - def remove_selected_class(self): - """Remove selected class""" - current_item = self.class_list.currentItem() - if current_item: - # Parse class ID from item text - text = current_item.text() - class_id = int(text.split(":")[0]) - - # Remove from classes dict - if class_id in self.classes: - del self.classes[class_id] - - # Remove from list - self.class_list.takeItem(self.class_list.row(current_item)) - - def get_current_class_id(self) -> Optional[int]: - """Get currently selected class ID""" - current_item = self.class_list.currentItem() - if current_item: - text = current_item.text() - return int(text.split(":")[0]) - return None - - def get_classes(self) -> Dict[int, str]: - """Get all classes""" - return self.classes.copy() - - -class DataEngineMainWindow(QMainWindow): - """Main window for the Data Engine application""" - - def __init__(self): - super().__init__() - self.setWindowTitle("SAM2 Data Engine - YOLO Dataset Generator") - self.setGeometry(100, 100, 1400, 900) - - # Initialize variables - self.video_path = None - self.output_dir = None - self.frames = [] - self.current_frame_idx = 0 - self.sam_model = None - self.frame_cache = {} - self.masks_cache = {} - self.annotations = {} # frame_idx: [annotations] - - # Thread pool for SAM processing - self.thread_pool = QThreadPool() - - self.setup_ui() - self.load_sam_model() - - def setup_ui(self): - """Setup the user interface""" - central_widget = QWidget() - self.setCentralWidget(central_widget) - - # Main layout - main_layout = QHBoxLayout() - - # Left panel - Controls - left_panel = self.create_left_panel() - - # Center panel - Frame viewer - center_panel = self.create_center_panel() - - # Right panel - Object classes and annotations - right_panel = self.create_right_panel() - - # Create splitter for resizable panels - splitter = QSplitter(Qt.Horizontal) - splitter.addWidget(left_panel) - splitter.addWidget(center_panel) - splitter.addWidget(right_panel) - splitter.setSizes([300, 700, 300]) - - main_layout.addWidget(splitter) - central_widget.setLayout(main_layout) - - def create_left_panel(self) -> QWidget: - """Create the left control panel""" - panel = QWidget() - layout = QVBoxLayout() - - # Video loading group - video_group = QGroupBox("Video Loading") - video_layout = QVBoxLayout() - - self.load_video_btn = QPushButton("Load Video") - self.load_video_btn.clicked.connect(self.load_video) - - self.video_path_label = QLabel("No video loaded") - self.video_path_label.setWordWrap(True) - - self.output_dir_btn = QPushButton("Set Output Directory") - self.output_dir_btn.clicked.connect(self.set_output_directory) - - self.output_dir_label = QLabel("No output directory set") - self.output_dir_label.setWordWrap(True) - - video_layout.addWidget(self.load_video_btn) - video_layout.addWidget(self.video_path_label) - video_layout.addWidget(self.output_dir_btn) - video_layout.addWidget(self.output_dir_label) - video_group.setLayout(video_layout) - - # Frame navigation group - nav_group = QGroupBox("Frame Navigation") - nav_layout = QVBoxLayout() - - # Frame slider - self.frame_slider = QSlider(Qt.Horizontal) - self.frame_slider.valueChanged.connect(self.on_frame_changed) - - # Frame controls - frame_controls = QHBoxLayout() - self.prev_btn = QPushButton("◀ Prev") - self.prev_btn.clicked.connect(self.prev_frame) - - self.frame_spinbox = QSpinBox() - self.frame_spinbox.valueChanged.connect(self.on_frame_spinbox_changed) - - self.next_btn = QPushButton("Next ▶") - self.next_btn.clicked.connect(self.next_frame) - - frame_controls.addWidget(self.prev_btn) - frame_controls.addWidget(self.frame_spinbox) - frame_controls.addWidget(self.next_btn) - - nav_layout.addWidget(QLabel("Frame:")) - nav_layout.addWidget(self.frame_slider) - nav_layout.addLayout(frame_controls) - nav_group.setLayout(nav_layout) - - # SAM controls group - sam_group = QGroupBox("SAM2 Controls") - sam_layout = QVBoxLayout() - - # Point selection mode - point_mode_layout = QHBoxLayout() - self.positive_point_btn = QPushButton("Positive Point") - self.positive_point_btn.setCheckable(True) - self.positive_point_btn.setChecked(True) - self.positive_point_btn.clicked.connect(lambda: self.set_point_mode(1)) - - self.negative_point_btn = QPushButton("Negative Point") - self.negative_point_btn.setCheckable(True) - self.negative_point_btn.clicked.connect(lambda: self.set_point_mode(0)) - - point_mode_layout.addWidget(self.positive_point_btn) - point_mode_layout.addWidget(self.negative_point_btn) - - # SAM action buttons - self.clear_points_btn = QPushButton("Clear Points") - self.clear_points_btn.clicked.connect(self.clear_points) - - self.segment_btn = QPushButton("Segment Object") - self.segment_btn.clicked.connect(self.segment_current_frame) - - # Propagation controls - prop_layout = QHBoxLayout() - self.propagate_forward_btn = QPushButton("Propagate Forward") - self.propagate_forward_btn.clicked.connect(self.propagate_forward) - - self.propagate_backward_btn = QPushButton("Propagate Backward") - self.propagate_backward_btn.clicked.connect(self.propagate_backward) - - prop_layout.addWidget(self.propagate_forward_btn) - prop_layout.addWidget(self.propagate_backward_btn) - - sam_layout.addLayout(point_mode_layout) - sam_layout.addWidget(self.clear_points_btn) - sam_layout.addWidget(self.segment_btn) - sam_layout.addLayout(prop_layout) - sam_group.setLayout(sam_layout) - - # Export group - export_group = QGroupBox("Export") - export_layout = QVBoxLayout() - - self.export_yolo_btn = QPushButton("Export YOLO Dataset") - self.export_yolo_btn.clicked.connect(self.export_yolo_dataset) - - self.progress_bar = QProgressBar() - - export_layout.addWidget(self.export_yolo_btn) - export_layout.addWidget(self.progress_bar) - export_group.setLayout(export_layout) - - # Add all groups to layout - layout.addWidget(video_group) - layout.addWidget(nav_group) - layout.addWidget(sam_group) - layout.addWidget(export_group) - layout.addStretch() - - panel.setLayout(layout) - return panel - - def create_center_panel(self) -> QWidget: - """Create the center frame viewer panel""" - panel = QWidget() - layout = QVBoxLayout() - - # Frame viewer - self.frame_viewer = FrameViewer() - self.frame_viewer.point_clicked.connect(self.on_point_clicked) - - layout.addWidget(self.frame_viewer) - panel.setLayout(layout) - return panel - - def create_right_panel(self) -> QWidget: - """Create the right panel for classes and annotations""" - panel = QWidget() - layout = QVBoxLayout() - - # Object class manager - self.class_manager = ObjectClassManager() - - # Current annotations - annotations_group = QGroupBox("Current Frame Annotations") - annotations_layout = QVBoxLayout() - - self.annotations_list = QListWidget() - - remove_annotation_btn = QPushButton("Remove Selected Annotation") - remove_annotation_btn.clicked.connect(self.remove_annotation) - - annotations_layout.addWidget(self.annotations_list) - annotations_layout.addWidget(remove_annotation_btn) - annotations_group.setLayout(annotations_layout) - - # Statistics - stats_group = QGroupBox("Statistics") - stats_layout = QVBoxLayout() - - self.stats_label = QTextEdit() - self.stats_label.setMaximumHeight(150) - self.stats_label.setReadOnly(True) - - stats_layout.addWidget(self.stats_label) - stats_group.setLayout(stats_layout) - - layout.addWidget(self.class_manager) - layout.addWidget(annotations_group) - layout.addWidget(stats_group) - - panel.setLayout(layout) - return panel - - def load_sam_model(self): - """Load the SAM2 model""" - try: - self.sam_model = SAM("sam2_b.pt") # Use SAM2 base model - print("SAM2 model loaded successfully") - except Exception as e: - QMessageBox.warning( - self, "Model Loading Error", f"Failed to load SAM2 model: {e}" - ) - - def load_video(self): - """Load a video file""" - file_path, _ = QFileDialog.getOpenFileName( - self, - "Select Video File", - "", - "Video Files (*.mp4 *.avi *.mov *.mkv *.wmv);;All Files (*)", - ) - - if file_path: - self.video_path = file_path - self.video_path_label.setText(f"Video: {Path(file_path).name}") - self.load_video_frames() - - def set_output_directory(self): - """Set the output directory for the dataset""" - dir_path = QFileDialog.getExistingDirectory(self, "Select Output Directory") - - if dir_path: - self.output_dir = dir_path - self.output_dir_label.setText(f"Output: {Path(dir_path).name}") - - def load_video_frames(self): - """Load frames from the video""" - if not self.video_path: - return - - try: - cap = cv2.VideoCapture(self.video_path) - total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) - - # Setup frame navigation - self.frame_slider.setMaximum(total_frames - 1) - self.frame_spinbox.setMaximum(total_frames - 1) - - # Cache first frame for immediate display - cap.set(cv2.CAP_PROP_POS_FRAMES, 0) - ret, frame = cap.read() - if ret: - self.frame_cache[0] = frame - self.frame_viewer.set_frame(frame) - - cap.release() - - # Start background frame caching - if self.output_dir: - self.cache_frames_async() - - self.update_stats() - - except Exception as e: - QMessageBox.critical(self, "Error", f"Failed to load video: {e}") - - def cache_frames_async(self): - """Cache frames asynchronously""" - cache_dir = Path(self.output_dir) / "cache" / "frames" - cache_dir.mkdir(parents=True, exist_ok=True) - - # Process video frames in background - self.video_processor = VideoProcessor(self.video_path, str(cache_dir)) - self.video_processor.frame_processed.connect(self.on_frame_cached) - self.video_processor.progress_updated.connect(self.progress_bar.setValue) - self.video_processor.start() - - def on_frame_cached(self, frame_idx: int, frame: np.ndarray): - """Handle cached frame""" - self.frame_cache[frame_idx] = frame - - def on_frame_changed(self, frame_idx: int): - """Handle frame slider change""" - self.current_frame_idx = frame_idx - self.frame_spinbox.setValue(frame_idx) - self.load_current_frame() - self.update_annotations_display() - - def on_frame_spinbox_changed(self, frame_idx: int): - """Handle frame spinbox change""" - self.frame_slider.setValue(frame_idx) - - def load_current_frame(self): - """Load and display the current frame""" - if self.current_frame_idx in self.frame_cache: - frame = self.frame_cache[self.current_frame_idx] - self.frame_viewer.set_frame(frame) - else: - # Load frame from video if not cached - self.load_frame_from_video(self.current_frame_idx) - - def load_frame_from_video(self, frame_idx: int): - """Load a specific frame from video""" - if not self.video_path: - return - - try: - cap = cv2.VideoCapture(self.video_path) - cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx) - ret, frame = cap.read() - cap.release() - - if ret: - self.frame_cache[frame_idx] = frame - self.frame_viewer.set_frame(frame) - except Exception as e: - print(f"Error loading frame {frame_idx}: {e}") - - def prev_frame(self): - """Go to previous frame""" - if self.current_frame_idx > 0: - self.frame_slider.setValue(self.current_frame_idx - 1) - - def next_frame(self): - """Go to next frame""" - max_frame = self.frame_slider.maximum() - if self.current_frame_idx < max_frame: - self.frame_slider.setValue(self.current_frame_idx + 1) - - def set_point_mode(self, mode: int): - """Set point selection mode""" - self.frame_viewer.set_click_mode(mode) - - # Update button states - self.positive_point_btn.setChecked(mode == 1) - self.negative_point_btn.setChecked(mode == 0) - - def clear_points(self): - """Clear all points on current frame""" - self.frame_viewer.clear_points() - - def on_point_clicked(self, x: int, y: int, label: int): - """Handle point click on frame""" - print(f"Point clicked: ({x}, {y}), label: {label}") - - def segment_current_frame(self): - """Segment object in current frame using SAM2""" - if not self.sam_model or self.current_frame_idx not in self.frame_cache: - QMessageBox.warning(self, "Error", "No model loaded or frame not available") - return - - if not self.frame_viewer.points: - QMessageBox.warning(self, "Error", "Please add at least one point") - return - - current_class_id = self.class_manager.get_current_class_id() - if current_class_id is None: - QMessageBox.warning(self, "Error", "Please select a class") - return - - # Prepare points and labels for SAM - points = np.array([[x, y] for x, y, _ in self.frame_viewer.points]) - labels = np.array([label for _, _, label in self.frame_viewer.points]) - - frame = self.frame_cache[self.current_frame_idx] - - # Run SAM segmentation - try: - results = self.sam_model(frame, points=points, labels=labels) - - if results and len(results) > 0: - result = results[0] - if hasattr(result, "masks") and result.masks is not None: - # Get the best mask - mask = result.masks.data[0].cpu().numpy() - - # Store annotation - self.store_annotation( - self.current_frame_idx, mask, current_class_id - ) - self.update_annotations_display() - - # Cache mask - self.cache_mask(self.current_frame_idx, mask, current_class_id) - - except Exception as e: - QMessageBox.critical(self, "Segmentation Error", f"Failed to segment: {e}") - - def store_annotation(self, frame_idx: int, mask: np.ndarray, class_id: int): - """Store annotation for a frame""" - if frame_idx not in self.annotations: - self.annotations[frame_idx] = [] - - annotation = { - "mask": mask, - "class_id": class_id, - "class_name": self.class_manager.classes.get(class_id, "unknown"), - } - - self.annotations[frame_idx].append(annotation) - - def cache_mask(self, frame_idx: int, mask: np.ndarray, class_id: int): - """Cache mask to disk""" - if not self.output_dir: - return - - cache_dir = Path(self.output_dir) / "cache" / "masks" - cache_dir.mkdir(parents=True, exist_ok=True) - - mask_path = cache_dir / f"frame_{frame_idx:06d}_class_{class_id}.pt" - torch.save(torch.from_numpy(mask), mask_path) - - def propagate_forward(self): - """Propagate segmentation forward""" - # TODO: Implement SAM2 video tracking for forward propagation - QMessageBox.information(self, "Info", "Forward propagation not yet implemented") - - def propagate_backward(self): - """Propagate segmentation backward""" - # TODO: Implement SAM2 video tracking for backward propagation - QMessageBox.information( - self, "Info", "Backward propagation not yet implemented" - ) - - def update_annotations_display(self): - """Update the annotations list for current frame""" - self.annotations_list.clear() - - if self.current_frame_idx in self.annotations: - for i, annotation in enumerate(self.annotations[self.current_frame_idx]): - class_name = annotation["class_name"] - item_text = f"Object {i}: {class_name}" - self.annotations_list.addItem(item_text) - - def remove_annotation(self): - """Remove selected annotation""" - current_item = self.annotations_list.currentItem() - if current_item and self.current_frame_idx in self.annotations: - row = self.annotations_list.row(current_item) - if 0 <= row < len(self.annotations[self.current_frame_idx]): - del self.annotations[self.current_frame_idx][row] - self.update_annotations_display() - - def export_yolo_dataset(self): - """Export annotations in YOLO format""" - if not self.output_dir: - QMessageBox.warning(self, "Error", "Please set output directory first") - return - - if not self.annotations: - QMessageBox.warning(self, "Error", "No annotations to export") - return - - try: - self.create_yolo_dataset() - QMessageBox.information( - self, "Success", "YOLO dataset exported successfully" - ) - except Exception as e: - QMessageBox.critical(self, "Export Error", f"Failed to export dataset: {e}") - - def create_yolo_dataset(self): - """Create YOLO format dataset""" - dataset_dir = Path(self.output_dir) / "yolo_dataset" - images_dir = dataset_dir / "images" - labels_dir = dataset_dir / "labels" - - images_dir.mkdir(parents=True, exist_ok=True) - labels_dir.mkdir(parents=True, exist_ok=True) - - # Create classes.txt - classes_file = dataset_dir / "classes.txt" - with open(classes_file, "w") as f: - classes = self.class_manager.get_classes() - for class_id in sorted(classes.keys()): - f.write(f"{classes[class_id]}\n") - - # Export annotated frames - for frame_idx, annotations in self.annotations.items(): - if frame_idx not in self.frame_cache: - continue - - # Save image - frame = self.frame_cache[frame_idx] - image_path = images_dir / f"frame_{frame_idx:06d}.jpg" - cv2.imwrite(str(image_path), frame) - - # Save labels - label_path = labels_dir / f"frame_{frame_idx:06d}.txt" - with open(label_path, "w") as f: - for annotation in annotations: - # Convert mask to YOLO segmentation format - mask = annotation["mask"] - class_id = annotation["class_id"] - - # Find contours from mask - mask_uint8 = (mask * 255).astype(np.uint8) - contours, _ = cv2.findContours( - mask_uint8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE - ) - - if contours: - # Use the largest contour - largest_contour = max(contours, key=cv2.contourArea) - - # Normalize coordinates - h, w = frame.shape[:2] - normalized_contour = [] - - for point in largest_contour: - x, y = point[0] - normalized_contour.extend([x / w, y / h]) - - # Write YOLO segmentation line - if len(normalized_contour) >= 6: # At least 3 points - line = f"{class_id} " + " ".join( - [f"{coord:.6f}" for coord in normalized_contour] - ) - f.write(line + "\n") - - def update_stats(self): - """Update statistics display""" - total_frames = len(self.frame_cache) - annotated_frames = len(self.annotations) - total_annotations = sum(len(anns) for anns in self.annotations.values()) - - stats_text = f""" -Total Frames: {total_frames} -Annotated Frames: {annotated_frames} -Total Annotations: {total_annotations} -Current Frame: {self.current_frame_idx} - """ - - self.stats_label.setText(stats_text.strip()) +# Import modularized GUI components +from gui import DataEngineMainWindow +from PySide6.QtWidgets import QApplication def main(): diff --git a/data_engine/run.py b/data_engine/run.py deleted file mode 100644 index 243ed5d..0000000 --- a/data_engine/run.py +++ /dev/null @@ -1,100 +0,0 @@ -#!/usr/bin/env python3 -""" -Launch script for the SAM2 Data Engine -""" - -import os -import sys -from pathlib import Path - -# Add the data_engine directory to Python path -data_engine_dir = Path(__file__).parent -sys.path.insert(0, str(data_engine_dir)) - - -def check_dependencies(): - """Check if all required dependencies are installed""" - missing_deps = [] - - try: - import cv2 - except ImportError: - missing_deps.append("opencv-python") - - try: - import numpy - except ImportError: - missing_deps.append("numpy") - - try: - import torch - except ImportError: - missing_deps.append("torch") - - try: - from PySide6 import QtWidgets - except ImportError: - missing_deps.append("PySide6") - - try: - from ultralytics import SAM - except ImportError: - missing_deps.append("ultralytics") - - try: - from PIL import Image - except ImportError: - missing_deps.append("Pillow") - - if missing_deps: - print("Missing dependencies:") - for dep in missing_deps: - print(f" - {dep}") - print("\nPlease install missing dependencies:") - print(f"pip install {' '.join(missing_deps)}") - print("\nOr run the setup script:") - print("python setup.py") - return False - - return True - - -def main(): - """Main launch function""" - print("SAM2 Data Engine") - print("=" * 30) - - # Check dependencies - if not check_dependencies(): - print("\nDependency check failed!") - return 1 - - print("✓ All dependencies found") - - # Check for CUDA - try: - import torch - - if torch.cuda.is_available(): - print(f"✓ CUDA available: {torch.cuda.get_device_name()}") - else: - print("⚠ CUDA not available, using CPU") - except: - print("⚠ Could not check CUDA availability") - - # Launch the application - try: - print("\nLaunching Data Engine...") - from main import main as app_main - - return app_main() - except ImportError as e: - print(f"Error importing main application: {e}") - return 1 - except Exception as e: - print(f"Error launching application: {e}") - return 1 - - -if __name__ == "__main__": - sys.exit(main()) diff --git a/data_engine/sam_processor.py b/data_engine/sam_processor.py deleted file mode 100644 index 763ada9..0000000 --- a/data_engine/sam_processor.py +++ /dev/null @@ -1,510 +0,0 @@ -#!/usr/bin/env python3 -""" -SAM2 Integration Module -Handles SAM2 model loading, inference, and video tracking -""" - -import os -from pathlib import Path -from typing import Any, Dict, List, Optional, Tuple - -import cv2 -import numpy as np -import torch - -try: - from ultralytics import SAM -except ImportError: - print("Warning: ultralytics not installed. SAM functionality will be limited.") - SAM = None - - -class SAM2Processor: - """SAM2 model processor for image segmentation and video tracking""" - - def __init__(self, model_path: str = "sam2_b.pt", device: str = "auto"): - """ - Initialize SAM2 processor - - Args: - model_path: Path to SAM2 model file - device: Device to run model on ('cpu', 'cuda', 'auto') - """ - self.model_path = model_path - self.device = self._get_device(device) - self.model = None - self.is_loaded = False - - # Video tracking state - self.tracking_state = {} - self.current_video_features = None - - self.load_model() - - def _get_device(self, device: str) -> str: - """Determine the best device to use""" - if device == "auto": - return "cuda" if torch.cuda.is_available() else "cpu" - return device - - def load_model(self) -> bool: - """ - Load the SAM2 model - - Returns: - True if model loaded successfully - """ - try: - if SAM is None: - print("SAM not available - ultralytics not installed") - return False - - self.model = SAM(self.model_path) - self.is_loaded = True - print(f"SAM2 model loaded successfully on {self.device}") - return True - - except Exception as e: - print(f"Failed to load SAM2 model: {e}") - self.is_loaded = False - return False - - def segment_with_points( - self, - image: np.ndarray, - points: np.ndarray, - labels: np.ndarray, - multimask_output: bool = False, - ) -> Dict[str, Any]: - """ - Segment image using point prompts - - Args: - image: Input image (RGB) - points: Array of point coordinates [[x1, y1], [x2, y2], ...] - labels: Array of point labels [1, 0, 1, ...] (1=positive, 0=negative) - multimask_output: Whether to output multiple masks - - Returns: - Dictionary containing masks and other outputs - """ - if not self.is_loaded: - return {"masks": None, "error": "Model not loaded"} - - try: - # Run SAM2 prediction - results = self.model(image, points=points, labels=labels) - - if results and len(results) > 0: - result = results[0] - - output = { - "masks": None, - "scores": None, - "logits": None, - "success": True, - } - - if hasattr(result, "masks") and result.masks is not None: - # Extract mask data - masks = result.masks.data.cpu().numpy() - output["masks"] = masks - - # Extract scores if available - if hasattr(result.masks, "conf"): - output["scores"] = result.masks.conf.cpu().numpy() - - return output - else: - return { - "masks": None, - "error": "No results from model", - "success": False, - } - - except Exception as e: - return {"masks": None, "error": str(e), "success": False} - - def segment_with_box(self, image: np.ndarray, box: List[int]) -> Dict[str, Any]: - """ - Segment image using bounding box prompt - - Args: - image: Input image (RGB) - box: Bounding box [x1, y1, x2, y2] - - Returns: - Dictionary containing masks and other outputs - """ - if not self.is_loaded: - return {"masks": None, "error": "Model not loaded"} - - try: - results = self.model(image, bboxes=[box]) - - if results and len(results) > 0: - result = results[0] - - output = {"masks": None, "scores": None, "success": True} - - if hasattr(result, "masks") and result.masks is not None: - masks = result.masks.data.cpu().numpy() - output["masks"] = masks - - if hasattr(result.masks, "conf"): - output["scores"] = result.masks.conf.cpu().numpy() - - return output - else: - return { - "masks": None, - "error": "No results from model", - "success": False, - } - - except Exception as e: - return {"masks": None, "error": str(e), "success": False} - - def initialize_video_tracking(self, first_frame: np.ndarray) -> bool: - """ - Initialize video tracking with the first frame - - Args: - first_frame: First frame of the video - - Returns: - True if initialization successful - """ - try: - # This would typically encode the first frame for tracking - # For now, we'll store the frame and prepare for tracking - self.tracking_state = { - "initialized": True, - "frame_count": 0, - "objects": {}, # object_id -> tracking_info - } - - # In a full SAM2 implementation, this would: - # 1. Encode the frame with the image encoder - # 2. Store image features for efficient tracking - # 3. Initialize memory banks for object tracking - - return True - - except Exception as e: - print(f"Failed to initialize video tracking: {e}") - return False - - def add_tracking_object( - self, frame: np.ndarray, points: np.ndarray, labels: np.ndarray, object_id: int - ) -> bool: - """ - Add a new object to track in the video - - Args: - frame: Current frame - points: Point prompts - labels: Point labels - object_id: Unique ID for the object - - Returns: - True if object added successfully - """ - try: - # Segment the object in the current frame - result = self.segment_with_points(frame, points, labels) - - if result["success"] and result["masks"] is not None: - # Store object information for tracking - self.tracking_state["objects"][object_id] = { - "mask": result["masks"][0], # Use the best mask - "last_frame": self.tracking_state["frame_count"], - "points": points, - "labels": labels, - } - return True - - return False - - except Exception as e: - print(f"Failed to add tracking object: {e}") - return False - - def propagate_masks( - self, frames: List[np.ndarray], start_frame_idx: int, direction: str = "forward" - ) -> Dict[int, Dict[int, np.ndarray]]: - """ - Propagate masks across multiple frames - - Args: - frames: List of frames to process - start_frame_idx: Index of the starting frame - direction: 'forward' or 'backward' - - Returns: - Dictionary mapping frame_idx -> {object_id -> mask} - """ - results = {} - - if not self.tracking_state.get("initialized", False): - return results - - try: - # For each frame, propagate masks for all tracked objects - frame_indices = range(len(frames)) - if direction == "backward": - frame_indices = reversed(frame_indices) - - for frame_idx in frame_indices: - if frame_idx == start_frame_idx: - continue - - frame = frames[frame_idx] - frame_results = {} - - # Propagate each tracked object - for object_id, obj_info in self.tracking_state["objects"].items(): - # In a full SAM2 implementation, this would: - # 1. Use temporal features from previous frames - # 2. Apply object tracking algorithms - # 3. Refine masks based on motion and appearance - - # For now, we'll use a simplified approach - propagated_mask = self._simple_mask_propagation( - frame, - obj_info["mask"], - obj_info.get("points"), - obj_info.get("labels"), - ) - - if propagated_mask is not None: - frame_results[object_id] = propagated_mask - - if frame_results: - results[frame_idx] = frame_results - - return results - - except Exception as e: - print(f"Failed to propagate masks: {e}") - return {} - - def _simple_mask_propagation( - self, - frame: np.ndarray, - reference_mask: np.ndarray, - points: Optional[np.ndarray] = None, - labels: Optional[np.ndarray] = None, - ) -> Optional[np.ndarray]: - """ - Simple mask propagation using template matching or re-segmentation - - Args: - frame: Current frame - reference_mask: Mask from previous frame - points: Original point prompts (optional) - labels: Original point labels (optional) - - Returns: - Propagated mask or None if failed - """ - try: - # Method 1: If we have original points, re-segment - if points is not None and labels is not None: - result = self.segment_with_points(frame, points, labels) - if result["success"] and result["masks"] is not None: - return result["masks"][0] - - # Method 2: Use template matching or other computer vision techniques - # This is a placeholder for more sophisticated tracking - # In practice, SAM2 would use temporal attention and memory mechanisms - - return None - - except Exception as e: - print(f"Simple mask propagation failed: {e}") - return None - - def save_features_cache( - self, cache_path: str, frame_idx: int, features: torch.Tensor - ): - """ - Save encoded features to cache for faster processing - - Args: - cache_path: Path to cache directory - frame_idx: Frame index - features: Encoded features tensor - """ - try: - cache_dir = Path(cache_path) - cache_dir.mkdir(parents=True, exist_ok=True) - - features_file = cache_dir / f"features_frame_{frame_idx:06d}.pt" - torch.save(features, features_file) - - except Exception as e: - print(f"Failed to save features cache: {e}") - - def load_features_cache( - self, cache_path: str, frame_idx: int - ) -> Optional[torch.Tensor]: - """ - Load encoded features from cache - - Args: - cache_path: Path to cache directory - frame_idx: Frame index - - Returns: - Cached features tensor or None if not found - """ - try: - cache_dir = Path(cache_path) - features_file = cache_dir / f"features_frame_{frame_idx:06d}.pt" - - if features_file.exists(): - return torch.load(features_file, map_location=self.device) - - return None - - except Exception as e: - print(f"Failed to load features cache: {e}") - return None - - def clear_tracking_state(self): - """Clear all tracking state""" - self.tracking_state = {} - self.current_video_features = None - - def get_model_info(self) -> Dict[str, Any]: - """ - Get information about the loaded model - - Returns: - Dictionary with model information - """ - info = { - "model_path": self.model_path, - "device": self.device, - "is_loaded": self.is_loaded, - "tracking_initialized": self.tracking_state.get("initialized", False), - "tracked_objects_count": len(self.tracking_state.get("objects", {})), - } - - if self.model and hasattr(self.model, "model"): - try: - # Try to get model parameters info - total_params = sum(p.numel() for p in self.model.model.parameters()) - info["total_parameters"] = total_params - except: - pass - - return info - - -def create_sam_processor( - model_name: str = "sam2_b.pt", device: str = "auto" -) -> SAM2Processor: - """ - Factory function to create SAM2 processor - - Args: - model_name: Name of the SAM2 model - device: Device to run on - - Returns: - SAM2Processor instance - """ - return SAM2Processor(model_name, device) - - -# Utility functions for SAM2 integration - - -def visualize_masks( - image: np.ndarray, - masks: List[np.ndarray], - colors: Optional[List[Tuple[int, int, int]]] = None, - alpha: float = 0.5, -) -> np.ndarray: - """ - Visualize multiple masks on an image - - Args: - image: Base image - masks: List of binary masks - colors: Colors for each mask - alpha: Transparency - - Returns: - Image with mask overlays - """ - if not masks: - return image - - result = image.copy() - - # Generate colors if not provided - if colors is None: - colors = [] - for i in range(len(masks)): - # Generate distinct colors - hue = (i * 137.5) % 360 # Golden angle approximation - color = tuple( - int(c) - for c in cv2.cvtColor(np.uint8([[[hue, 255, 255]]]), cv2.COLOR_HSV2RGB)[ - 0 - ][0] - ) - colors.append(color) - - # Apply each mask - for mask, color in zip(masks, colors): - if len(mask.shape) > 2: - mask = mask[0] # Take first mask if multiple - - mask_colored = np.zeros_like(image) - mask_colored[mask > 0] = color - - result = cv2.addWeighted(result, 1 - alpha, mask_colored, alpha, 0) - - return result - - -def masks_to_rle(masks: List[np.ndarray]) -> List[Dict]: - """ - Convert masks to Run-Length Encoding format - - Args: - masks: List of binary masks - - Returns: - List of RLE dictionaries - """ - rle_list = [] - - for mask in masks: - if len(mask.shape) > 2: - mask = mask[0] - - # Simple RLE encoding - flat_mask = mask.flatten() - rle = [] - current_val = flat_mask[0] - count = 1 - - for val in flat_mask[1:]: - if val == current_val: - count += 1 - else: - rle.extend([count, current_val]) - current_val = val - count = 1 - - rle.extend([count, current_val]) - - rle_dict = {"counts": rle, "size": list(mask.shape)} - rle_list.append(rle_dict) - - return rle_list diff --git a/data_engine/setup.py b/data_engine/setup.py deleted file mode 100644 index 7cf6355..0000000 --- a/data_engine/setup.py +++ /dev/null @@ -1,136 +0,0 @@ -#!/usr/bin/env python3 -""" -Setup script for the SAM2 Data Engine -""" - -import os -import subprocess -import sys -from pathlib import Path - - -def install_requirements(): - """Install required packages""" - requirements_file = Path(__file__).parent / "requirements.txt" - - if not requirements_file.exists(): - print("Requirements file not found!") - return False - - try: - print("Installing requirements...") - subprocess.check_call( - [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)] - ) - print("Requirements installed successfully!") - return True - except subprocess.CalledProcessError as e: - print(f"Failed to install requirements: {e}") - return False - - -def download_sam_models(): - """Download SAM2 models""" - try: - print("Downloading SAM2 models...") - # This will download the model when first used - from ultralytics import SAM - - # Try to load different SAM2 models - models = ["sam2_b.pt", "sam2_l.pt", "sam2_s.pt"] - - for model_name in models: - try: - print(f"Downloading {model_name}...") - sam = SAM(model_name) - print(f"✓ {model_name} downloaded successfully") - break # Download at least one model - except Exception as e: - print(f"Failed to download {model_name}: {e}") - continue - - return True - - except ImportError: - print("Ultralytics not installed. Please install requirements first.") - return False - except Exception as e: - print(f"Failed to download models: {e}") - return False - - -def create_directories(): - """Create necessary directories""" - base_dir = Path(__file__).parent - directories = [ - "cache", - "cache/frames", - "cache/masks", - "cache/features", - "projects", - "exports", - ] - - for dir_name in directories: - dir_path = base_dir / dir_name - dir_path.mkdir(parents=True, exist_ok=True) - print(f"Created directory: {dir_path}") - - -def check_system_requirements(): - """Check system requirements""" - print("Checking system requirements...") - - # Check Python version - if sys.version_info < (3, 8): - print("Error: Python 3.8 or higher is required") - return False - - print(f"✓ Python {sys.version_info.major}.{sys.version_info.minor}") - - # Check for CUDA (optional) - try: - import torch - - if torch.cuda.is_available(): - print(f"✓ CUDA available: {torch.cuda.get_device_name()}") - else: - print("⚠ CUDA not available, will use CPU (slower)") - except ImportError: - print("⚠ PyTorch not installed yet") - - return True - - -def main(): - """Main setup function""" - print("=" * 50) - print("SAM2 Data Engine Setup") - print("=" * 50) - - # Check system requirements - if not check_system_requirements(): - return False - - # Install requirements - if not install_requirements(): - return False - - # Create directories - create_directories() - - # Download models - if not download_sam_models(): - print("⚠ Model download failed, but you can try again later") - - print("\n" + "=" * 50) - print("Setup completed!") - print("You can now run the data engine with: python main.py") - print("=" * 50) - - return True - - -if __name__ == "__main__": - success = main() - sys.exit(0 if success else 1) diff --git a/scripts/I want to work.md b/scripts/I want to work.md new file mode 100644 index 0000000..0ca52b8 --- /dev/null +++ b/scripts/I want to work.md @@ -0,0 +1,14 @@ +I want to work on a automatic data_engine that usees viual prompts to interact with the ai models. What I want is to create a gui application build in python with the library pyside6. This gui should take the user inputs and ingest it t an ai model to at the end generate a yolo training dataset. So we will be using the model sam2 for automatic video segmentation. We will be able to go back and firth select the exact frame we want to work on. Cache inside a folder every individual. image with their generated mask. Each mask should have assigned an object with a name. it should save in the yolo format the segmentation the class and of the object type classification. + +We will be using the model sam2 from ultralytics please check this link for reference https://docs.ultralytics.com/models/sam-2/ + +some of the requirements are the following + +Move Back Forth in the frames +Conduct a Forward and Backwards Propagation from the selected frame. +Cache the frames in the file system. +Cache the Image-Encoder output from From SAM2 if using it. save it in a .pt file for later. +Save all the outputs in a YOLO dataset format. + + +create this on a folder called_data_engine diff --git a/third_party/sam2 b/third_party/sam2 new file mode 160000 index 0000000..2b90b9f --- /dev/null +++ b/third_party/sam2 @@ -0,0 +1 @@ +Subproject commit 2b90b9f5ceec907a1c18123530e92e794ad901a4 From 07d993fa036af8b97c011d648efe3609ddf98c5a Mon Sep 17 00:00:00 2001 From: Cruiz102 Date: Mon, 23 Jun 2025 23:41:14 -0400 Subject: [PATCH 3/8] made usable the application from docker --- data_engine/Dockerfile | 16 ++++++++++++++ data_engine/docker-compose.yml | 40 +++------------------------------- data_engine/setup_x11.sh | 30 +++++++++++++++++++++++++ 3 files changed, 49 insertions(+), 37 deletions(-) create mode 100644 data_engine/setup_x11.sh diff --git a/data_engine/Dockerfile b/data_engine/Dockerfile index 39e3310..1b8b191 100644 --- a/data_engine/Dockerfile +++ b/data_engine/Dockerfile @@ -17,6 +17,22 @@ RUN apt-get update && apt-get install -y \ libqt5core5a \ libqt5widgets5 \ qt5-gtk-platformtheme \ + libxcb1 \ + libxcb-xkb1 \ + libxkbcommon-x11-0 \ + libxcb-icccm4 \ + libxcb-image0 \ + libxcb-keysyms1 \ + libxcb-randr0 \ + libxcb-render-util0 \ + libxcb-render0 \ + libxcb-shape0 \ + libxcb-sync1 \ + libxcb-xfixes0 \ + libxcb-xinerama0 \ + libxcb-xinput0 \ + libxcb-cursor0 \ + x11-apps \ && rm -rf /var/lib/apt/lists/* # Set working directory diff --git a/data_engine/docker-compose.yml b/data_engine/docker-compose.yml index 0a03bd2..72936bc 100644 --- a/data_engine/docker-compose.yml +++ b/data_engine/docker-compose.yml @@ -1,5 +1,3 @@ -version: '3.8' - services: sam2-data-engine: build: @@ -19,12 +17,9 @@ services: # X11 Display support environment: - - DISPLAY=${DISPLAY:-:0.0} + - DISPLAY=${DISPLAY} - QT_X11_NO_MITSHM=1 - - QT_QPA_PLATFORM=xcb - XAUTHORITY=/tmp/.docker.xauth - - NVIDIA_VISIBLE_DEVICES=all - - NVIDIA_DRIVER_CAPABILITIES=all # Mount X11 socket and auth volumes: @@ -34,36 +29,7 @@ services: - ./cache:/app/cache:rw - ./projects:/app/projects:rw - ./exports:/app/exports:rw - - ./videos:/app/videos:ro # Mount your video files here + - ./videos:/app/videos:ro - # Network mode for X11 + privileged: True network_mode: host - - # Security options - security_opt: - - seccomp:unconfined - - # Additional privileges for GPU access - privileged: false - - # IPC mode for shared memory - ipc: host - - # Restart policy - restart: unless-stopped - - - -# Networks (optional - using host network for X11) -networks: - default: - driver: bridge - -# Volumes for persistent data -volumes: - sam2_cache: - driver: local - sam2_projects: - driver: local - sam2_exports: - driver: local diff --git a/data_engine/setup_x11.sh b/data_engine/setup_x11.sh new file mode 100644 index 0000000..145e448 --- /dev/null +++ b/data_engine/setup_x11.sh @@ -0,0 +1,30 @@ +#!/bin/bash + +# Setup X11 authentication for Docker GUI applications +echo "Setting up X11 authentication for Docker..." + +# Create X11 auth file if it doesn't exist +XAUTH_FILE="/tmp/.docker.xauth" + +# Remove old auth file if it exists +if [ -f "$XAUTH_FILE" ]; then + rm "$XAUTH_FILE" +fi + +# Create new auth file +touch "$XAUTH_FILE" + +# Add current display to auth file +xauth nlist "$DISPLAY" | sed -e 's/^..../ffff/' | xauth -f "$XAUTH_FILE" nmerge - + +# Set proper permissions +chmod 644 "$XAUTH_FILE" + +echo "X11 authentication setup complete!" +echo "DISPLAY: $DISPLAY" +echo "XAUTH_FILE: $XAUTH_FILE" + +# Allow X11 connections from localhost (for Docker) +xhost +local:docker + +echo "You can now run: docker compose up" From 1d3cf670375be0a564dda596ad4451a14f502ffa Mon Sep 17 00:00:00 2001 From: Cruiz102 Date: Sun, 13 Jul 2025 16:42:06 -0400 Subject: [PATCH 4/8] added example video and default models. --- .pre-commit-config.yaml | 1 - data_engine/Dockerfile | 16 ++++++++++++++++ data_engine/docker-compose.yml | 3 ++- data_engine/setup_x11.sh | 0 data_engine/videos/example.mp4 | Bin 0 -> 542742 bytes 5 files changed, 18 insertions(+), 2 deletions(-) mode change 100644 => 100755 data_engine/setup_x11.sh create mode 100644 data_engine/videos/example.mp4 diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 3603777..35edbe7 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -5,7 +5,6 @@ repos: - id: trailing-whitespace - id: end-of-file-fixer - id: check-yaml - - id: check-added-large-files - id: check-merge-conflict - repo: https://github.com/psf/black diff --git a/data_engine/Dockerfile b/data_engine/Dockerfile index 1b8b191..6f35446 100644 --- a/data_engine/Dockerfile +++ b/data_engine/Dockerfile @@ -44,6 +44,22 @@ COPY requirements.txt . # Install Python dependencies RUN pip install --no-cache-dir -r requirements.txt +# Create models directory and config directory +RUN mkdir -p /app/models /app/.config + +# Set environment variables for Ultralytics +ENV YOLO_CONFIG_DIR=/app/.config + +# Download SAM2 models during build time +RUN python -c "from ultralytics import SAM; model = SAM('sam2_b.pt'); print('SAM2 base model downloaded')" +RUN python -c "from ultralytics import SAM; model = SAM('sam2_l.pt'); print('SAM2 large model downloaded')" +RUN python -c "from ultralytics import SAM; model = SAM('sam2_s.pt'); print('SAM2 small model downloaded')" + +# Download YOLOv8 models during build time +RUN python -c "from ultralytics import YOLO; model = YOLO('yolov8n.pt'); print('YOLOv8 nano model downloaded')" +RUN python -c "from ultralytics import YOLO; model = YOLO('yolov8s.pt'); print('YOLOv8 small model downloaded')" +RUN python -c "from ultralytics import YOLO; model = YOLO('yolov8m.pt'); print('YOLOv8 medium model downloaded')" + # Copy the current directory contents COPY . . diff --git a/data_engine/docker-compose.yml b/data_engine/docker-compose.yml index 72936bc..ba15548 100644 --- a/data_engine/docker-compose.yml +++ b/data_engine/docker-compose.yml @@ -20,16 +20,17 @@ services: - DISPLAY=${DISPLAY} - QT_X11_NO_MITSHM=1 - XAUTHORITY=/tmp/.docker.xauth + - YOLO_CONFIG_DIR=/app/.config # Mount X11 socket and auth volumes: - /tmp/.X11-unix:/tmp/.X11-unix:rw - - /tmp/.docker.xauth:/tmp/.docker.xauth:rw - ./data:/app/data:rw - ./cache:/app/cache:rw - ./projects:/app/projects:rw - ./exports:/app/exports:rw - ./videos:/app/videos:ro + - ../yolo_models:/app/yolo_models:rw privileged: True network_mode: host diff --git a/data_engine/setup_x11.sh b/data_engine/setup_x11.sh old mode 100644 new mode 100755 diff --git a/data_engine/videos/example.mp4 b/data_engine/videos/example.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..283fe64cee927c2b1b4cca4c35756d9d09c0caca GIT binary patch literal 542742 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%0D0;5&X1=5D(j3G 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 z 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ë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�>cf#nP_*97?g%bU0C|YxVxEsrx4?WH2ukC2A@fFJIq`Cl=uzsUEqZtB^w?6 ziGUll&&@_+V?!`cS1N973TOO521_G7k50U%Pu{mH2e8A>uB0^>mYlu^x|d(QSO2IZ zc9P|@0J!t@viYTI3XnG?BVb&3e$G2*2-4ynej`@C+=7_jxq>QcOd~LZd^NOJP{dVa z#H0)d!cqK`bn-j)2`O6l_Ez2uN>o%p@WZ!^tK`uo+3>O;~Yw9g16qNU^_2@QiK-%@`QBJIE=k4N3 z*oJdaZJ^il3m`l9Xa2ppXZpyZmf!>=l`xvU&4sW(r}tg(uuqC=ifu4zWX7W1@0s^X z7ZtEFJwMCaGCEhe-1yF|3pSwb*u(8AUWWVz7k*@9jma=ABPj+Mu$J zdm^m-z`PnFuu{LSuNs~&%n0QevYBWK29kNx;$G7tedeLuK_F1_N2JG19$|>b1)A1q zSDCQUD21peKMB+m#l)x0A+=tnz8UNv;$O?LD%2Z?5v5INFt-&>hRvh7Sl-$nmKN{8 z#us<^5_DRyc#fR{Wrt4IQvHGYYoNyo{&;nmRfIf`_jm<{@g%mxoC0(a;E|NW*X1Lb zBP%*k>!d4p_49FISU{bIF69D67fpvd{42TV$fPhL`v-=b(xAp#JV-cXBoFGEj zL)bYPMZK{9e`dq-DVSi{H0Em~BV42k6xHeI0wT!0m`ooYh{&e>CkXl}%cqO7gtHZxF3P0buNE%R*`) zaoJj__aVW;+mvKv(=B(3If{P(B+%N0nJKoqnBN-ygzy75XiIsDxl9o;3o}PyibTp1mRSC{>c7_l4%U| zhu>up?|^g}Ug^>A3~4;oZ_M3^T;^l8@1py`Fv4IvpvBj!zbSlagY5;n$`=-)8F#Cc zx#G_-8P9Zw3n0pV&M5_&4<1k;lg1uimllZL-2S#<*HpitxI+2U83M#41Yjlb4@p4W zo$RrzxLvYnh-+!^V70exyrF)9BDj;K;{wTsEC9Thq8Wc#je zGmx;2XQ(13DY%z+y*L!=-`(^h!;Q|jShT!tyYCmjKJ~nkTYmhSj2)S=6Qmp7cm4= z$NsUqMT@H~sm2p|cCb4`k*j!#x1;Q`(h`tMu<@7v4Tyc3*d

{{iV5veOY!>=ih?9ueP)8z5I=5Y#YH|M(U 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

Wym-A9HAbrHwGxx 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

E@VZ&>NyQ{HMeKR=9J`wYdz zq$%9@IjSNnc($ve+$lW1>!>YrdjXAC4&&)g6TfXkZH|jRzuHvH*Q6LsiZi2*#Ocu>uR2N>eQA)7ctDULx;~Ml@KnUGM1)^1(kt|@yXjn^>JASc zYUGWBSeQ_zC~;a_D}V@}o2?uV%O6U=wmdcb(QZWiiZ1 z9ZqayJ0(TMG%2FjVGW(tAo6n~aRDxqv_*Ya17HV*vlR0&xfep-F(iKz~2~RsOFE!2Ta~f&bF{-zab(CY6(;ffXRs zcCz{>Cd7YJ{I@qC?*Ah=F>}XB$FB%fzo0Fk6KzDz0`u3jz`KwcH z0KC=T44oYR)yYVNexSbq z0^xjf`ey(D@*f>%5C|B1Ko@A&-+}pC{%sEiGWsuFqJQy$LHb7y^>6%-Euatcw+>YP zsl)#>nE&X({af!pc7LmX{r|`A|5pwe{m1VAiudWi`2Sa2;DY^M^?`W*D<9|ogOBuY zJ^|1tM*n2|fBFOj^w;0~!43hL+rMRh5x{2x@pKwyf(3Sa!(afzf(P8N z_y7iyMaBiXngXCd05sqm?HH(cfk3Fz0L}t|DAs@>st4Xdn*#7AKp-j$5C~5aI5-lx zF%jZ;RF#tdf&_M)z zM*;j+01g1~0qlYNkpMZ$E|60u5Puxd1#(0Kazg>)p>BadBw|1vnA|XwK%mb{fcz4W zg#!Sz3k~pz&H-Sc4FtfrppOEu3INb2sB-}J0&p*YfrcT50yGs6PXhpPz#eEj;urv0 z!0H{y34tBp1NkBXw+rD6Fa~u14djUo+zTiuK-&Ns9vCO27=Vun&};w({2>7CL_i1N zC*a2hfIy%Vf&0S94#0m47yyg_7&;p}0c{0o+L-)<0TT4_zfVTM1mlF0Wz{Qk}gPxt0o{5q1{{i7r-~Rvr literal 0 HcmV?d00001 From b0719c72159c409d4bac244f8b3e88e112b86eda Mon Sep 17 00:00:00 2001 From: Cruiz102 Date: Sun, 13 Jul 2025 17:31:50 -0400 Subject: [PATCH 5/8] gpt goes brr with sam2 --- data_engine/Dockerfile | 29 +- data_engine/gui/frame_viewer.py | 103 +++++-- data_engine/gui/left_panel.py | 71 ++++- data_engine/gui/main_window.py | 394 ++++++++++++++++----------- data_engine/gui/sam2_video_worker.py | 273 +++++++++++++++++++ data_engine/requirements.txt | 4 + data_engine/test_imports.py | 69 +++++ 7 files changed, 769 insertions(+), 174 deletions(-) create mode 100644 data_engine/gui/sam2_video_worker.py create mode 100644 data_engine/test_imports.py diff --git a/data_engine/Dockerfile b/data_engine/Dockerfile index 6f35446..5a2209a 100644 --- a/data_engine/Dockerfile +++ b/data_engine/Dockerfile @@ -1,7 +1,7 @@ # SAM2 Data Engine Dockerfile FROM pytorch/pytorch:2.7.1-cuda12.6-cudnn9-runtime -# Install system dependencies for GUI applications +# Install system dependencies for GUI applications and git RUN apt-get update && apt-get install -y \ libgl1-mesa-glx \ libglib2.0-0 \ @@ -33,24 +33,47 @@ RUN apt-get update && apt-get install -y \ libxcb-xinput0 \ libxcb-cursor0 \ x11-apps \ + git \ + wget \ && rm -rf /var/lib/apt/lists/* # Set working directory WORKDIR /app +# Clone SAM2 repository +RUN git clone https://github.com/facebookresearch/segment-anything-2.git /app/third_party/sam2 + # Copy requirements first for better caching COPY requirements.txt . -# Install Python dependencies +# Install Python dependencies including SAM2 RUN pip install --no-cache-dir -r requirements.txt +RUN cd /app/third_party/sam2 && pip install -e . # Create models directory and config directory -RUN mkdir -p /app/models /app/.config +RUN mkdir -p /app/models /app/.config /app/sam2_models # Set environment variables for Ultralytics ENV YOLO_CONFIG_DIR=/app/.config +ENV YOLO_CONFIG_DIR=/app/.config # Download SAM2 models during build time +RUN python3 -c "\ +import sys; \ +sys.path.append('/app/third_party/sam2'); \ +import os; \ +import urllib.request; \ +os.makedirs('/app/sam2_models', exist_ok=True); \ +checkpoint_urls = { \ + 'sam2_hiera_tiny.pt': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_tiny.pt', \ + 'sam2_hiera_small.pt': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_small.pt', \ + 'sam2_hiera_base_plus.pt': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_base_plus.pt', \ + 'sam2_hiera_large.pt': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_large.pt' \ +}; \ +[urllib.request.urlretrieve(url, f'/app/sam2_models/{filename}') for filename, url in checkpoint_urls.items() if not os.path.exists(f'/app/sam2_models/{filename}')]; \ +print('All SAM2 models downloaded')" + +# Download Ultralytics SAM models during build time RUN python -c "from ultralytics import SAM; model = SAM('sam2_b.pt'); print('SAM2 base model downloaded')" RUN python -c "from ultralytics import SAM; model = SAM('sam2_l.pt'); print('SAM2 large model downloaded')" RUN python -c "from ultralytics import SAM; model = SAM('sam2_s.pt'); print('SAM2 small model downloaded')" diff --git a/data_engine/gui/frame_viewer.py b/data_engine/gui/frame_viewer.py index 60df08b..3fd164f 100644 --- a/data_engine/gui/frame_viewer.py +++ b/data_engine/gui/frame_viewer.py @@ -4,7 +4,7 @@ import cv2 import numpy as np -from PySide6.QtCore import Signal +from PySide6.QtCore import Qt, Signal from PySide6.QtGui import QImage, QPixmap from PySide6.QtWidgets import QLabel @@ -20,17 +20,31 @@ def __init__(self): super().__init__() self.setMinimumSize(640, 480) self.setStyleSheet("border: 2px solid gray;") - self.setScaledContents(True) + self.setScaledContents(False) # Don't stretch - maintain aspect ratio + self.setAlignment(Qt.AlignCenter) # Center the image self.current_frame = None self.scale_factor = 1.0 self.click_mode = 1 # 1 for positive, 0 for negative self.points = [] # List of (x, y, label) tuples + self.masks = [] # List of masks to overlay def set_frame(self, frame: np.ndarray): """Set the current frame to display""" self.current_frame = frame.copy() self.update_display() + def add_mask( + self, mask: np.ndarray, color: tuple = (0, 255, 0), alpha: float = 0.3 + ): + """Add a segmentation mask to display""" + self.masks.append({"mask": mask, "color": color, "alpha": alpha}) + self.update_display() + + def clear_masks(self): + """Clear all segmentation masks""" + self.masks.clear() + self.update_display() + def set_click_mode(self, mode: int): """Set click mode: 1 for positive points, 0 for negative points""" self.click_mode = mode @@ -46,12 +60,44 @@ def clear_points(self): self.update_display() def update_display(self): - """Update the display with current frame and points""" + """Update the display with current frame, masks, and points""" if self.current_frame is None: return display_frame = self.current_frame.copy() + # Draw segmentation masks + for mask_info in self.masks: + mask = mask_info["mask"] + color = mask_info["color"] + alpha = mask_info["alpha"] + + # Ensure mask is the same size as frame + if mask.shape[:2] != display_frame.shape[:2]: + mask = cv2.resize( + mask.astype(np.uint8), + (display_frame.shape[1], display_frame.shape[0]), + ) + + # Create colored overlay + overlay = display_frame.copy() + mask_bool = mask > 0 + overlay[mask_bool] = color + + # Blend with original frame + display_frame = cv2.addWeighted(display_frame, 1 - alpha, overlay, alpha, 0) + + # Add mask contours + if mask.dtype != np.uint8: + mask_uint8 = (mask * 255).astype(np.uint8) + else: + mask_uint8 = mask + + contours, _ = cv2.findContours( + mask_uint8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE + ) + cv2.drawContours(display_frame, contours, -1, color, 2) + # Draw points for x, y, label in self.points: color = ( @@ -60,35 +106,58 @@ def update_display(self): cv2.circle(display_frame, (x, y), 5, color, -1) cv2.circle(display_frame, (x, y), 7, (255, 255, 255), 2) - # Convert to QPixmap + # Convert to QPixmap with proper aspect ratio height, width, channel = display_frame.shape bytes_per_line = 3 * width q_image = QImage( display_frame.data, width, height, bytes_per_line, QImage.Format_RGB888 ).rgbSwapped() + + # Scale pixmap to fit widget while maintaining aspect ratio pixmap = QPixmap.fromImage(q_image) - self.setPixmap(pixmap) + widget_size = self.size() + scaled_pixmap = pixmap.scaled( + widget_size, Qt.KeepAspectRatio, Qt.SmoothTransformation + ) + + self.setPixmap(scaled_pixmap) def mousePressEvent(self, event): """Handle mouse click events""" - if self.current_frame is None: + if self.current_frame is None or self.pixmap() is None: return # Get click position relative to the actual image widget_size = self.size() - pixmap_size = self.pixmap().size() if self.pixmap() else widget_size + pixmap_size = self.pixmap().size() - # Calculate scale factors - scale_x = self.current_frame.shape[1] / pixmap_size.width() - scale_y = self.current_frame.shape[0] / pixmap_size.height() + # Calculate the actual displayed image position and size + # (since we use Qt.KeepAspectRatio and center alignment) + scale_x = pixmap_size.width() / self.current_frame.shape[1] + scale_y = pixmap_size.height() / self.current_frame.shape[0] + scale = min(scale_x, scale_y) + + # Calculate the displayed image size + display_width = int(self.current_frame.shape[1] * scale) + display_height = int(self.current_frame.shape[0] * scale) + + # Calculate offset (centering) + offset_x = (widget_size.width() - display_width) // 2 + offset_y = (widget_size.height() - display_height) // 2 # Convert widget coordinates to image coordinates - x = int(event.position().x() * scale_x) - y = int(event.position().y() * scale_y) + click_x = event.position().x() - offset_x + click_y = event.position().y() - offset_y + + # Check if click is within the image bounds + if 0 <= click_x <= display_width and 0 <= click_y <= display_height: + # Convert to original image coordinates + x = int(click_x / scale) + y = int(click_y / scale) - # Ensure coordinates are within bounds - x = max(0, min(x, self.current_frame.shape[1] - 1)) - y = max(0, min(y, self.current_frame.shape[0] - 1)) + # Ensure coordinates are within bounds + x = max(0, min(x, self.current_frame.shape[1] - 1)) + y = max(0, min(y, self.current_frame.shape[0] - 1)) - self.add_point(x, y, self.click_mode) - self.point_clicked.emit(x, y, self.click_mode) + self.add_point(x, y, self.click_mode) + self.point_clicked.emit(x, y, self.click_mode) diff --git a/data_engine/gui/left_panel.py b/data_engine/gui/left_panel.py index 8c2e315..0511b72 100644 --- a/data_engine/gui/left_panel.py +++ b/data_engine/gui/left_panel.py @@ -6,9 +6,12 @@ from PySide6.QtCore import Qt from PySide6.QtWidgets import ( + QCheckBox, QGroupBox, QHBoxLayout, QLabel, + QListWidget, + QProgressBar, QPushButton, QSlider, QSpinBox, @@ -37,6 +40,9 @@ def setup_ui(self): # SAM controls group sam_group = self.create_sam_group() + # SAM2 Video Tracking group + sam2_group = self.create_sam2_group() + # Export group export_group = self.create_export_group() @@ -44,6 +50,7 @@ def setup_ui(self): layout.addWidget(video_group) layout.addWidget(nav_group) layout.addWidget(sam_group) + layout.addWidget(sam2_group) layout.addWidget(export_group) layout.addStretch() @@ -132,10 +139,70 @@ def create_sam_group(self) -> QGroupBox: return sam_group + def create_sam2_group(self) -> QGroupBox: + """Create SAM2 Video Tracking group""" + sam2_group = QGroupBox("SAM2 Video Tracking") + sam2_layout = QVBoxLayout() + + # Video initialization + self.init_video_btn = QPushButton("Initialize Video Tracking") + self.init_video_btn.setEnabled(False) + + # Object management + object_controls = QHBoxLayout() + self.add_object_btn = QPushButton("Add Object") + self.add_object_btn.setEnabled(False) + self.remove_object_btn = QPushButton("Remove Object") + self.remove_object_btn.setEnabled(False) + + object_controls.addWidget(self.add_object_btn) + object_controls.addWidget(self.remove_object_btn) + + # Tracked objects list + self.tracked_objects_list = QListWidget() + self.tracked_objects_list.setMaximumHeight(100) + + # Propagation controls + prop_controls = QHBoxLayout() + self.propagate_forward_btn = QPushButton("Propagate Forward") + self.propagate_forward_btn.setEnabled(False) + self.propagate_backward_btn = QPushButton("Propagate Backward") + self.propagate_backward_btn.setEnabled(False) + + prop_controls.addWidget(self.propagate_forward_btn) + prop_controls.addWidget(self.propagate_backward_btn) + + # Clear tracking + self.clear_tracking_btn = QPushButton("Clear All Tracking") + self.clear_tracking_btn.setEnabled(False) + + # Auto-propagation option + self.auto_propagate_checkbox = QCheckBox("Auto-propagate on frame change") + + # Progress bar for tracking operations + self.tracking_progress = QProgressBar() + self.tracking_progress.setVisible(False) + + # Status label + self.tracking_status_label = QLabel("Video tracking not initialized") + self.tracking_status_label.setWordWrap(True) + + # Add all controls to layout + sam2_layout.addWidget(self.init_video_btn) + sam2_layout.addWidget(QLabel("Tracked Objects:")) + sam2_layout.addWidget(self.tracked_objects_list) + sam2_layout.addLayout(object_controls) + sam2_layout.addLayout(prop_controls) + sam2_layout.addWidget(self.clear_tracking_btn) + sam2_layout.addWidget(self.auto_propagate_checkbox) + sam2_layout.addWidget(self.tracking_progress) + sam2_layout.addWidget(self.tracking_status_label) + + sam2_group.setLayout(sam2_layout) + return sam2_group + def create_export_group(self) -> QGroupBox: """Create export group""" - from PySide6.QtWidgets import QProgressBar - export_group = QGroupBox("Export") export_layout = QVBoxLayout() diff --git a/data_engine/gui/main_window.py b/data_engine/gui/main_window.py index 999b9c5..e6e5a26 100644 --- a/data_engine/gui/main_window.py +++ b/data_engine/gui/main_window.py @@ -27,22 +27,11 @@ SAM = None # Import local modules -try: - from config import get_config_manager - from sam_processor import SAM2Processor - from utils import create_directory_structure, export_statistics -except ImportError as e: - print(f"Warning: Could not import local modules: {e}") - SAM2Processor = None - get_config_manager = None - create_directory_structure = None - export_statistics = None - -from .center_panel import CenterPanel from .frame_viewer import FrameViewer from .left_panel import LeftControlPanel from .right_panel import RightPanel -from .workers import SAMProcessor, VideoProcessor +from .sam2_video_worker import SAM2VideoWorker +from .workers import VideoProcessor class DataEngineMainWindow(QMainWindow): @@ -66,8 +55,16 @@ def __init__(self): # Thread pool for SAM processing self.thread_pool = QThreadPool() + # SAM2 Video Worker for advanced tracking + self.sam2_worker = SAM2VideoWorker() + self.video_tracking_enabled = False + self.tracked_objects = {} # obj_id -> object_info + self.next_object_id = 0 + self.propagation_results = {} # frame_idx -> {obj_id: mask} + self.setup_ui() self.connect_signals() + self.connect_sam2_signals() self.load_sam_model() def setup_ui(self): @@ -107,7 +104,7 @@ def connect_signals(self): self.left_panel.prev_btn.clicked.connect(self.prev_frame) self.left_panel.next_btn.clicked.connect(self.next_frame) - # SAM controls + # SAM controls (single frame) self.left_panel.positive_point_btn.clicked.connect( lambda: self.set_point_mode(1) ) @@ -116,8 +113,21 @@ def connect_signals(self): ) self.left_panel.clear_points_btn.clicked.connect(self.clear_points) self.left_panel.segment_btn.clicked.connect(self.segment_current_frame) - self.left_panel.propagate_forward_btn.clicked.connect(self.propagate_forward) - self.left_panel.propagate_backward_btn.clicked.connect(self.propagate_backward) + + # SAM2 Video Tracking controls + self.left_panel.init_video_btn.clicked.connect(self.init_video_tracking) + self.left_panel.add_object_btn.clicked.connect(self.add_tracked_object) + self.left_panel.remove_object_btn.clicked.connect(self.remove_tracked_object) + self.left_panel.propagate_forward_btn.clicked.connect( + self.propagate_forward_sam2 + ) + self.left_panel.propagate_backward_btn.clicked.connect( + self.propagate_backward_sam2 + ) + self.left_panel.clear_tracking_btn.clicked.connect(self.clear_all_tracking) + self.left_panel.tracked_objects_list.itemSelectionChanged.connect( + self.on_object_selection_changed + ) # Export self.left_panel.export_yolo_btn.clicked.connect(self.export_yolo_dataset) @@ -128,14 +138,31 @@ def connect_signals(self): # Right panel signals self.right_panel.remove_annotation_btn.clicked.connect(self.remove_annotation) + def connect_sam2_signals(self): + """Connect SAM2 worker signals""" + self.sam2_worker.model_loaded.connect(self.on_sam2_model_loaded) + self.sam2_worker.video_initialized.connect(self.on_video_initialized) + self.sam2_worker.object_added.connect(self.on_object_added) + self.sam2_worker.propagation_progress.connect(self.on_propagation_progress) + self.sam2_worker.propagation_complete.connect(self.on_propagation_complete) + self.sam2_worker.error_occurred.connect(self.on_sam2_error) + def load_sam_model(self): - """Load the SAM2 model""" + """Load both SAM2 video model and fallback SAM model""" try: - self.sam_model = SAM("sam2_b.pt") # Use SAM2 base model - print("SAM2 model loaded successfully") + # Load SAM2 video model for tracking + self.sam2_worker.load_model("sam2_hiera_base_plus.pt") + + # Load fallback SAM model for single-frame segmentation + if SAM is not None: + self.sam_model = SAM("sam2_b.pt") # Use SAM2 base model + print("Fallback SAM model loaded successfully") except Exception as e: + print(f"Warning: Failed to load models: {e}") QMessageBox.warning( - self, "Model Loading Error", f"Failed to load SAM2 model: {e}" + self, + "Model Loading Warning", + f"Some models failed to load: {e}\nSome features may be limited.", ) def load_video(self): @@ -152,6 +179,12 @@ def load_video(self): self.left_panel.video_path_label.setText(f"Video: {Path(file_path).name}") self.load_video_frames() + # Enable SAM2 video tracking controls + self.left_panel.init_video_btn.setEnabled(True) + self.left_panel.tracking_status_label.setText( + "Video loaded. Click 'Initialize Video Tracking' to begin." + ) + def set_output_directory(self): """Set the output directory for the dataset""" dir_path = QFileDialog.getExistingDirectory(self, "Select Output Directory") @@ -224,6 +257,35 @@ def load_current_frame(self): if self.current_frame_idx in self.frame_cache: frame = self.frame_cache[self.current_frame_idx] self.frame_viewer.set_frame(frame) + + # Clear existing masks and load masks for this frame + self.frame_viewer.clear_masks() + + # Show manual annotations + if self.current_frame_idx in self.annotations: + for annotation in self.annotations[self.current_frame_idx]: + mask = annotation["mask"] + class_id = annotation["class_id"] + color = self.get_class_color(class_id) + self.frame_viewer.add_mask(mask, color=color, alpha=0.4) + + # Show SAM2 tracking results + if self.current_frame_idx in self.propagation_results: + for obj_id, mask in self.propagation_results[ + self.current_frame_idx + ].items(): + if obj_id in self.tracked_objects: + class_id = self.tracked_objects[obj_id]["class_id"] + color = self.get_class_color(class_id) + self.frame_viewer.add_mask(mask, color=color, alpha=0.3) + + # Show individual tracked object masks + for obj_id, obj_info in self.tracked_objects.items(): + if self.current_frame_idx in obj_info["masks"]: + mask = obj_info["masks"][self.current_frame_idx] + class_id = obj_info["class_id"] + color = self.get_class_color(class_id) + self.frame_viewer.add_mask(mask, color=color, alpha=0.3) else: # Load frame from video if not cached self.load_frame_from_video(self.current_frame_idx) @@ -245,6 +307,103 @@ def load_frame_from_video(self, frame_idx: int): except Exception as e: print(f"Error loading frame {frame_idx}: {e}") + def export_yolo_dataset(self): + """Export annotations in YOLO format""" + if not self.output_dir: + QMessageBox.warning(self, "Error", "Please set output directory first") + return + + if not self.annotations and not self.tracked_objects: + QMessageBox.warning(self, "Error", "No annotations to export") + return + + try: + self.create_yolo_dataset() + QMessageBox.information( + self, "Success", "YOLO dataset exported successfully" + ) + except Exception as e: + QMessageBox.critical(self, "Export Error", f"Failed to export dataset: {e}") + + def create_yolo_dataset(self): + """Create YOLO format dataset""" + if not self.output_dir: + raise ValueError("Output directory not set") + + dataset_dir = Path(self.output_dir) / "yolo_dataset" + images_dir = dataset_dir / "images" + labels_dir = dataset_dir / "labels" + + # Create directories + images_dir.mkdir(parents=True, exist_ok=True) + labels_dir.mkdir(parents=True, exist_ok=True) + + # Export frames and create YOLO annotations + all_frames = set(self.annotations.keys()) + all_frames.update( + self.tracked_objects.get(obj_id, {}).get("masks", {}).keys() + for obj_id in self.tracked_objects + ) + + for frame_idx in all_frames: + if frame_idx in self.frame_cache: + frame = self.frame_cache[frame_idx] + + # Save image + image_filename = f"frame_{frame_idx:06d}.jpg" + image_path = images_dir / image_filename + cv2.imwrite(str(image_path), frame) + + # Create YOLO label file + label_filename = f"frame_{frame_idx:06d}.txt" + label_path = labels_dir / label_filename + + with open(label_path, "w") as f: + # Write manual annotations + if frame_idx in self.annotations: + for annotation in self.annotations[frame_idx]: + mask = annotation["mask"] + class_id = annotation["class_id"] + bbox = self.mask_to_yolo_bbox(mask, frame.shape[:2]) + f.write(f"{class_id} {' '.join(map(str, bbox))}\n") + + # Write tracked object annotations + for obj_id, obj_info in self.tracked_objects.items(): + if frame_idx in obj_info["masks"]: + mask = obj_info["masks"][frame_idx] + class_id = obj_info["class_id"] + bbox = self.mask_to_yolo_bbox(mask, frame.shape[:2]) + f.write(f"{class_id} {' '.join(map(str, bbox))}\n") + + # Create classes.txt file + classes_path = dataset_dir / "classes.txt" + with open(classes_path, "w") as f: + for class_id, class_name in self.right_panel.class_manager.classes.items(): + f.write(f"{class_name}\n") + + print(f"YOLO dataset exported to {dataset_dir}") + + def mask_to_yolo_bbox(self, mask: np.ndarray, image_shape: tuple) -> list: + """Convert mask to YOLO format bounding box (normalized)""" + # Find bounding box of mask + rows = np.any(mask, axis=1) + cols = np.any(mask, axis=0) + + if not rows.any() or not cols.any(): + return [0.5, 0.5, 0.0, 0.0] # Default small box in center + + rmin, rmax = np.where(rows)[0][[0, -1]] + cmin, cmax = np.where(cols)[0][[0, -1]] + + # Convert to YOLO format (center_x, center_y, width, height) - normalized + h, w = image_shape + center_x = (cmin + cmax) / 2 / w + center_y = (rmin + rmax) / 2 / h + width = (cmax - cmin) / w + height = (rmax - rmin) / h + + return [center_x, center_y, width, height] + def prev_frame(self): """Go to previous frame""" if self.current_frame_idx > 0: @@ -257,8 +416,8 @@ def next_frame(self): self.left_panel.frame_slider.setValue(self.current_frame_idx + 1) def set_point_mode(self, mode: int): - """Set point selection mode""" - self.frame_viewer.set_click_mode(mode) + """Set point mode (0=negative, 1=positive)""" + self.frame_viewer.point_mode = mode # Update button states self.left_panel.positive_point_btn.setChecked(mode == 1) @@ -268,18 +427,16 @@ def clear_points(self): """Clear all points on current frame""" self.frame_viewer.clear_points() - def on_point_clicked(self, x: int, y: int, label: int): - """Handle point click on frame""" - print(f"Point clicked: ({x}, {y}), label: {label}") - def segment_current_frame(self): - """Segment object in current frame using SAM2""" - if not self.sam_model or self.current_frame_idx not in self.frame_cache: - QMessageBox.warning(self, "Error", "No model loaded or frame not available") + """Segment current frame using SAM""" + if not self.frame_viewer.points: + QMessageBox.warning( + self, "Error", "Please click points on the object first" + ) return - if not self.frame_viewer.points: - QMessageBox.warning(self, "Error", "Please add at least one point") + if self.sam_model is None: + QMessageBox.warning(self, "Error", "SAM model not loaded") return current_class_id = self.right_panel.class_manager.get_current_class_id() @@ -287,30 +444,44 @@ def segment_current_frame(self): QMessageBox.warning(self, "Error", "Please select a class") return - # Prepare points and labels for SAM - points = np.array([[x, y] for x, y, _ in self.frame_viewer.points]) - labels = np.array([label for _, _, label in self.frame_viewer.points]) + try: + # Get current frame + frame = self.frame_cache.get(self.current_frame_idx) + if frame is None: + QMessageBox.warning(self, "Error", "Frame not loaded") + return - frame = self.frame_cache[self.current_frame_idx] + # Prepare points for SAM + points = np.array([[x, y] for x, y, _ in self.frame_viewer.points]) + labels = np.array([label for _, _, label in self.frame_viewer.points]) - # Run SAM segmentation - try: + # Run SAM segmentation results = self.sam_model(frame, points=points, labels=labels) if results and len(results) > 0: - result = results[0] - if hasattr(result, "masks") and result.masks is not None: + masks = results[0].masks + if masks is not None: # Get the best mask - mask = result.masks.data[0].cpu().numpy() + mask = masks.data[0].cpu().numpy().astype(bool) # Store annotation self.store_annotation( self.current_frame_idx, mask, current_class_id ) + + # Update display + color = self.get_class_color(current_class_id) + self.frame_viewer.add_mask(mask, color=color, alpha=0.4) self.update_annotations_display() - # Cache mask - self.cache_mask(self.current_frame_idx, mask, current_class_id) + # Clear points + self.frame_viewer.clear_points() + + print(f"Segmentation completed for frame {self.current_frame_idx}") + else: + QMessageBox.warning(self, "Error", "No mask generated") + else: + QMessageBox.warning(self, "Error", "Segmentation failed") except Exception as e: QMessageBox.critical(self, "Segmentation Error", f"Failed to segment: {e}") @@ -330,29 +501,6 @@ def store_annotation(self, frame_idx: int, mask: np.ndarray, class_id: int): self.annotations[frame_idx].append(annotation) - def cache_mask(self, frame_idx: int, mask: np.ndarray, class_id: int): - """Cache mask to disk""" - if not self.output_dir: - return - - cache_dir = Path(self.output_dir) / "cache" / "masks" - cache_dir.mkdir(parents=True, exist_ok=True) - - mask_path = cache_dir / f"frame_{frame_idx:06d}_class_{class_id}.pt" - torch.save(torch.from_numpy(mask), mask_path) - - def propagate_forward(self): - """Propagate segmentation forward""" - # TODO: Implement SAM2 video tracking for forward propagation - QMessageBox.information(self, "Info", "Forward propagation not yet implemented") - - def propagate_backward(self): - """Propagate segmentation backward""" - # TODO: Implement SAM2 video tracking for backward propagation - QMessageBox.information( - self, "Info", "Backward propagation not yet implemented" - ) - def update_annotations_display(self): """Update the annotations list for current frame""" self.right_panel.annotations_list.clear() @@ -371,95 +519,37 @@ def remove_annotation(self): if 0 <= row < len(self.annotations[self.current_frame_idx]): del self.annotations[self.current_frame_idx][row] self.update_annotations_display() - - def export_yolo_dataset(self): - """Export annotations in YOLO format""" - if not self.output_dir: - QMessageBox.warning(self, "Error", "Please set output directory first") - return - - if not self.annotations: - QMessageBox.warning(self, "Error", "No annotations to export") - return - - try: - self.create_yolo_dataset() - QMessageBox.information( - self, "Success", "YOLO dataset exported successfully" - ) - except Exception as e: - QMessageBox.critical(self, "Export Error", f"Failed to export dataset: {e}") - - def create_yolo_dataset(self): - """Create YOLO format dataset""" - dataset_dir = Path(self.output_dir) / "yolo_dataset" - images_dir = dataset_dir / "images" - labels_dir = dataset_dir / "labels" - - images_dir.mkdir(parents=True, exist_ok=True) - labels_dir.mkdir(parents=True, exist_ok=True) - - # Create classes.txt - classes_file = dataset_dir / "classes.txt" - with open(classes_file, "w") as f: - classes = self.right_panel.class_manager.get_classes() - for class_id in sorted(classes.keys()): - f.write(f"{classes[class_id]}\n") - - # Export annotated frames - for frame_idx, annotations in self.annotations.items(): - if frame_idx not in self.frame_cache: - continue - - # Save image - frame = self.frame_cache[frame_idx] - image_path = images_dir / f"frame_{frame_idx:06d}.jpg" - cv2.imwrite(str(image_path), frame) - - # Save labels - label_path = labels_dir / f"frame_{frame_idx:06d}.txt" - with open(label_path, "w") as f: - for annotation in annotations: - # Convert mask to YOLO segmentation format - mask = annotation["mask"] - class_id = annotation["class_id"] - - # Find contours from mask - mask_uint8 = (mask * 255).astype(np.uint8) - contours, _ = cv2.findContours( - mask_uint8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE - ) - - if contours: - # Use the largest contour - largest_contour = max(contours, key=cv2.contourArea) - - # Normalize coordinates - h, w = frame.shape[:2] - normalized_contour = [] - - for point in largest_contour: - x, y = point[0] - normalized_contour.extend([x / w, y / h]) - - # Write YOLO segmentation line - if len(normalized_contour) >= 6: # At least 3 points - line = f"{class_id} " + " ".join( - [f"{coord:.6f}" for coord in normalized_contour] - ) - f.write(line + "\n") + self.load_current_frame() # Refresh display + + def get_class_color(self, class_id: int) -> tuple: + """Get color for a class ID""" + colors = [ + (255, 0, 0), # Red + (0, 255, 0), # Green + (0, 0, 255), # Blue + (255, 255, 0), # Yellow + (255, 0, 255), # Magenta + (0, 255, 255), # Cyan + (255, 128, 0), # Orange + (128, 0, 255), # Purple + ] + return colors[class_id % len(colors)] def update_stats(self): """Update statistics display""" - total_frames = len(self.frame_cache) + total_frames = ( + self.left_panel.frame_slider.maximum() + 1 if self.video_path else 0 + ) annotated_frames = len(self.annotations) - total_annotations = sum(len(anns) for anns in self.annotations.values()) - - stats_text = f""" -Total Frames: {total_frames} -Annotated Frames: {annotated_frames} -Total Annotations: {total_annotations} -Current Frame: {self.current_frame_idx} - """ + tracked_frames = len( + set().union( + *( + obj_info["masks"].keys() + for obj_info in self.tracked_objects.values() + ) + ) + ) - self.right_panel.stats_label.setText(stats_text.strip()) + stats_text = f"Total: {total_frames} frames | Annotated: {annotated_frames} | Tracked: {tracked_frames}" + # You can display this in a status bar or label if needed + print(stats_text) diff --git a/data_engine/gui/sam2_video_worker.py b/data_engine/gui/sam2_video_worker.py new file mode 100644 index 0000000..ddd31b8 --- /dev/null +++ b/data_engine/gui/sam2_video_worker.py @@ -0,0 +1,273 @@ +""" +SAM2 Video Worker for background video tracking operations +""" + +import os +import sys +from pathlib import Path + +import numpy as np +import torch +from PySide6.QtCore import QThread, Signal + +# Add SAM2 to path +sys.path.append("/app/third_party/sam2") +sys.path.append("/app/third_party/sam2/sam2") + +try: + from sam2.build_sam import build_sam2_video_predictor + from sam2.sam2_video_predictor import SAM2VideoPredictor + + SAM2_AVAILABLE = True +except ImportError as e: + print(f"SAM2 not available: {e}") + SAM2VideoPredictor = None + SAM2_AVAILABLE = False + + +class SAM2VideoWorker(QThread): + """Worker for SAM2 video tracking operations""" + + # Signals + video_initialized = Signal(bool, str) # success, message + object_added = Signal(int, dict) # obj_id, object_info + propagation_progress = Signal(int, int, str) # current_frame, total_frames, message + propagation_complete = Signal(dict) # frame_idx -> {obj_id: mask} + error_occurred = Signal(str) + model_loaded = Signal(bool, str) # success, message + + def __init__(self): + super().__init__() + self.predictor = None + self.inference_state = None + self.video_path = None + self.current_task = None + self.task_data = None + self.is_running = False + + def load_model(self, model_name="sam2_hiera_base_plus.pt"): + """Load SAM2 video predictor model""" + self.current_task = "load_model" + self.task_data = {"model_name": model_name} + self.start() + + def init_video(self, video_path): + """Initialize video for tracking""" + self.video_path = video_path + self.current_task = "init_video" + self.start() + + def add_object(self, frame_idx, points, labels, obj_id): + """Add new object for tracking""" + self.current_task = "add_object" + self.task_data = { + "frame_idx": frame_idx, + "points": points, + "labels": labels, + "obj_id": obj_id, + } + self.start() + + def propagate_video(self, start_frame=None, reverse=False, max_frames=None): + """Propagate tracking through video""" + self.current_task = "propagate" + self.task_data = { + "start_frame": start_frame, + "reverse": reverse, + "max_frames": max_frames, + } + self.start() + + def stop_current_task(self): + """Stop the current running task""" + self.is_running = False + + def run(self): + """Execute the current task""" + self.is_running = True + try: + if self.current_task == "load_model": + self._load_model() + elif self.current_task == "init_video": + self._init_video() + elif self.current_task == "add_object": + self._add_object() + elif self.current_task == "propagate": + self._propagate() + except Exception as e: + self.error_occurred.emit(f"Error in {self.current_task}: {str(e)}") + finally: + self.is_running = False + + def _load_model(self): + """Load SAM2 video predictor model""" + if not SAM2_AVAILABLE: + self.model_loaded.emit(False, "SAM2 not available") + return + + try: + model_name = self.task_data.get("model_name", "sam2_hiera_base_plus.pt") + + # Try different possible locations for the model + possible_paths = [ + f"/app/sam2_models/{model_name}", + f"/app/models/{model_name}", + f"/app/third_party/sam2/checkpoints/{model_name}", + model_name, # Let SAM2 handle download + ] + + model_path = None + for path in possible_paths: + if os.path.exists(path): + model_path = path + break + + if model_path is None: + model_path = model_name # Let SAM2 handle it + + # Determine config based on model name + if "tiny" in model_name: + config = "sam2_hiera_t.yaml" + elif "small" in model_name: + config = "sam2_hiera_s.yaml" + elif "base_plus" in model_name: + config = "sam2_hiera_b+.yaml" + elif "large" in model_name: + config = "sam2_hiera_l.yaml" + else: + config = "sam2_hiera_b+.yaml" # default + + # Try to find config file + config_path = f"/app/third_party/sam2/sam2/configs/{config}" + if not os.path.exists(config_path): + # Fallback to default config + config_path = config + + self.predictor = build_sam2_video_predictor(config_path, model_path) + self.model_loaded.emit(True, f"SAM2 model {model_name} loaded successfully") + + except Exception as e: + self.model_loaded.emit(False, f"Failed to load SAM2 model: {e}") + + def _init_video(self): + """Initialize video in SAM2""" + if not self.predictor or not self.video_path: + self.video_initialized.emit(False, "Model or video path not set") + return + + try: + self.inference_state = self.predictor.init_state( + video_path=self.video_path, + offload_video_to_cpu=True, # Save GPU memory + offload_state_to_cpu=False, + ) + + num_frames = self.inference_state.get("num_frames", 0) + self.video_initialized.emit( + True, f"Video initialized with {num_frames} frames" + ) + + except Exception as e: + self.video_initialized.emit(False, f"Failed to initialize video: {e}") + + def _add_object(self): + """Add object to tracking""" + if not self.predictor or not self.inference_state: + self.error_occurred.emit("SAM2 not initialized") + return + + data = self.task_data + try: + # Convert numpy arrays to proper format + points = np.array(data["points"], dtype=np.float32) + labels = np.array(data["labels"], dtype=np.int32) + + frame_idx, obj_ids, video_res_masks = self.predictor.add_new_points_or_box( + inference_state=self.inference_state, + frame_idx=data["frame_idx"], + obj_id=data["obj_id"], + points=points, + labels=labels, + normalize_coords=True, + ) + + # Extract mask for the new object + obj_idx = obj_ids.index(data["obj_id"]) + mask = video_res_masks[obj_idx].cpu().numpy() + + object_info = { + "obj_id": data["obj_id"], + "frame_idx": frame_idx, + "mask": mask, + } + self.object_added.emit(data["obj_id"], object_info) + + except Exception as e: + self.error_occurred.emit(f"Failed to add object: {e}") + + def _propagate(self): + """Propagate tracking through video""" + if not self.predictor or not self.inference_state: + self.error_occurred.emit("SAM2 not initialized") + return + + data = self.task_data + all_results = {} + + try: + total_frames = self.inference_state["num_frames"] + current_frame = 0 + + for ( + frame_idx, + obj_ids, + video_res_masks, + ) in self.predictor.propagate_in_video( + self.inference_state, + start_frame_idx=data.get("start_frame"), + max_frame_num_to_track=data.get("max_frames"), + reverse=data.get("reverse", False), + ): + if not self.is_running: + break + + # Convert masks to numpy and organize by object + frame_results = {} + for i, obj_id in enumerate(obj_ids): + mask = video_res_masks[i].cpu().numpy() + frame_results[obj_id] = mask + + all_results[frame_idx] = frame_results + current_frame += 1 + + # Emit progress + progress_msg = f"Processing frame {frame_idx}/{total_frames}" + self.propagation_progress.emit( + current_frame, total_frames, progress_msg + ) + + if self.is_running: + self.propagation_complete.emit(all_results) + + except Exception as e: + self.error_occurred.emit(f"Failed to propagate: {e}") + + def clear_object(self, obj_id): + """Clear/remove an object from tracking""" + if not self.predictor or not self.inference_state: + return + + try: + self.predictor.remove_object(self.inference_state, obj_id) + except Exception as e: + self.error_occurred.emit(f"Failed to remove object {obj_id}: {e}") + + def reset_tracking(self): + """Reset all tracking""" + if not self.predictor or not self.inference_state: + return + + try: + self.predictor.reset_state(self.inference_state) + except Exception as e: + self.error_occurred.emit(f"Failed to reset tracking: {e}") diff --git a/data_engine/requirements.txt b/data_engine/requirements.txt index 8473fac..e0c2b04 100644 --- a/data_engine/requirements.txt +++ b/data_engine/requirements.txt @@ -6,3 +6,7 @@ Pillow>=9.0.0 torch>=1.13.0 torchvision>=0.14.0 matplotlib>=3.5.0 +tqdm>=4.64.0 +hydra-core>=1.3.0 +iopath>=0.1.9 +fvcore>=0.1.5 diff --git a/data_engine/test_imports.py b/data_engine/test_imports.py new file mode 100644 index 0000000..01005e3 --- /dev/null +++ b/data_engine/test_imports.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python3 +""" +Quick test to verify imports and basic functionality +""" + +import sys + +print("Testing basic imports...") + +try: + import torch + + print(f"✓ PyTorch {torch.__version__}") +except ImportError as e: + print(f"✗ PyTorch: {e}") + +try: + import cv2 + + print(f"✓ OpenCV {cv2.__version__}") +except ImportError as e: + print(f"✗ OpenCV: {e}") + +try: + from ultralytics import SAM + + print("✓ Ultralytics SAM") +except ImportError as e: + print(f"✗ Ultralytics: {e}") + +try: + from PySide6.QtWidgets import QApplication + + print("✓ PySide6") +except ImportError as e: + print(f"✗ PySide6: {e}") + +print("\nTesting SAM2 imports...") +try: + sys.path.append("/app/third_party/sam2") + from sam2.sam2_video_predictor import SAM2VideoPredictor + + print("✓ SAM2VideoPredictor") +except ImportError as e: + print(f"✗ SAM2VideoPredictor: {e}") + +try: + from sam2.build_sam import build_sam2_video_predictor + + print("✓ build_sam2_video_predictor") +except ImportError as e: + print(f"✗ build_sam2_video_predictor: {e}") + +print("\nTesting GUI module imports...") +try: + from gui.sam2_video_worker import SAM2VideoWorker + + print("✓ SAM2VideoWorker") +except ImportError as e: + print(f"✗ SAM2VideoWorker: {e}") + +try: + from gui.main_window import DataEngineMainWindow + + print("✓ DataEngineMainWindow") +except ImportError as e: + print(f"✗ DataEngineMainWindow: {e}") + +print("\nAll import tests completed!") From af4584429b86b4565b64b998785f86c13a30d0ad Mon Sep 17 00:00:00 2001 From: Cruiz102 Date: Sun, 13 Jul 2025 21:31:51 -0400 Subject: [PATCH 6/8] I need to understand the code now. GPT stopped going brrr. --- data_engine/gui/frame_viewer.py | 109 +++++++++-- data_engine/gui/main_window.py | 265 +++++++++++++++++++++++++++ data_engine/gui/sam2_video_worker.py | 42 +++++ data_engine/requirements.txt | 1 + 4 files changed, 399 insertions(+), 18 deletions(-) diff --git a/data_engine/gui/frame_viewer.py b/data_engine/gui/frame_viewer.py index 3fd164f..e62af62 100644 --- a/data_engine/gui/frame_viewer.py +++ b/data_engine/gui/frame_viewer.py @@ -72,31 +72,104 @@ def update_display(self): color = mask_info["color"] alpha = mask_info["alpha"] - # Ensure mask is the same size as frame - if mask.shape[:2] != display_frame.shape[:2]: - mask = cv2.resize( - mask.astype(np.uint8), - (display_frame.shape[1], display_frame.shape[0]), - ) + # Validate mask + try: + if mask is None: + print("Warning: None mask, skipping") + continue + + # Convert to numpy array if needed + if not isinstance(mask, np.ndarray): + mask = np.array(mask) + + if mask.size == 0: + print("Warning: Empty mask, skipping") + continue + + # Ensure mask is 2D + if mask.ndim > 2: + mask = mask.squeeze() + if mask.ndim != 2: + print( + f"Warning: Mask has invalid dimensions {mask.shape}, skipping" + ) + continue + + # Ensure mask has valid dimensions + if mask.shape[0] == 0 or mask.shape[1] == 0: + print(f"Warning: Mask has zero dimensions {mask.shape}, skipping") + continue + + # Ensure we have valid frame dimensions + if display_frame.shape[0] <= 0 or display_frame.shape[1] <= 0: + continue + + # Resize mask to match frame if needed + if mask.shape[:2] != display_frame.shape[:2]: + # Ensure mask is uint8 for resize + if mask.dtype == np.bool_: + mask_for_resize = mask.astype(np.uint8) * 255 + elif mask.dtype in [np.float32, np.float64]: + mask_for_resize = (mask * 255).astype(np.uint8) + else: + mask_for_resize = mask.astype(np.uint8) + + # Check target dimensions are valid + target_height, target_width = display_frame.shape[:2] + if target_height <= 0 or target_width <= 0: + print( + f"Warning: Invalid target dimensions {target_height}x{target_width}, skipping" + ) + continue + + mask = cv2.resize( + mask_for_resize, + (target_width, target_height), + interpolation=cv2.INTER_NEAREST, + ) + + # Ensure final mask is binary + if mask.max() > 1: + mask_bool = mask > 127 + else: + mask_bool = mask > 0.5 + + except Exception as e: + print(f"Warning: Error processing mask: {e}") + continue # Create colored overlay overlay = display_frame.copy() - mask_bool = mask > 0 - overlay[mask_bool] = color + try: + overlay[mask_bool] = color + except Exception as e: + print(f"Warning: Failed to apply mask overlay: {e}") + continue # Blend with original frame - display_frame = cv2.addWeighted(display_frame, 1 - alpha, overlay, alpha, 0) + try: + display_frame = cv2.addWeighted( + display_frame, 1 - alpha, overlay, alpha, 0 + ) + except Exception as e: + print(f"Warning: Failed to blend overlay: {e}") + continue # Add mask contours - if mask.dtype != np.uint8: - mask_uint8 = (mask * 255).astype(np.uint8) - else: - mask_uint8 = mask - - contours, _ = cv2.findContours( - mask_uint8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE - ) - cv2.drawContours(display_frame, contours, -1, color, 2) + try: + # Convert mask to uint8 for contour detection + if mask.max() > 1: + mask_uint8 = mask.astype(np.uint8) + else: + mask_uint8 = (mask_bool * 255).astype(np.uint8) + + contours, _ = cv2.findContours( + mask_uint8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE + ) + cv2.drawContours(display_frame, contours, -1, color, 2) + except Exception as e: + print(f"Warning: Failed to draw contours: {e}") + continue # Draw points for x, y, label in self.points: diff --git a/data_engine/gui/main_window.py b/data_engine/gui/main_window.py index e6e5a26..0066a64 100644 --- a/data_engine/gui/main_window.py +++ b/data_engine/gui/main_window.py @@ -553,3 +553,268 @@ def update_stats(self): stats_text = f"Total: {total_frames} frames | Annotated: {annotated_frames} | Tracked: {tracked_frames}" # You can display this in a status bar or label if needed print(stats_text) + + def init_video_tracking(self): + """Initialize video for SAM2 tracking""" + if not self.video_path: + QMessageBox.warning(self, "Error", "Please load a video first") + return + + self.left_panel.tracking_status_label.setText("Initializing video tracking...") + self.left_panel.tracking_progress.setVisible(True) + self.sam2_worker.init_video(self.video_path) + + def add_tracked_object(self): + """Add a new object to track using current points""" + if not self.video_tracking_enabled: + QMessageBox.warning( + self, + "Error", + "Video tracking not initialized. Click 'Initialize Video Tracking' first.", + ) + return + + if not self.frame_viewer.points: + QMessageBox.warning( + self, "Error", "Please click points on the object to track" + ) + return + + current_class_id = self.right_panel.class_manager.get_current_class_id() + if current_class_id is None: + QMessageBox.warning(self, "Error", "Please select a class") + return + + # Prepare points for SAM2 + points = [[x, y] for x, y, _ in self.frame_viewer.points] + labels = [label for _, _, label in self.frame_viewer.points] + + # Create new object ID + obj_id = self.next_object_id + self.next_object_id += 1 + + # Store object info + self.tracked_objects[obj_id] = { + "class_id": current_class_id, + "class_name": self.right_panel.class_manager.classes.get( + current_class_id, "unknown" + ), + "masks": {}, + } + + # Add object to SAM2 tracking + self.sam2_worker.add_object( + frame_idx=self.current_frame_idx, + points=points, + labels=labels, + obj_id=obj_id, + ) + + def remove_tracked_object(self): + """Remove selected object from tracking""" + if not hasattr(self.left_panel, "tracked_objects_list"): + return + + current_item = self.left_panel.tracked_objects_list.currentItem() + if current_item: + # Extract object ID from item text + item_text = current_item.text() + try: + obj_id = int(item_text.split(":")[0].split()[-1]) + + # Remove from SAM2 + self.sam2_worker.clear_object(obj_id) + + # Remove from local storage + if obj_id in self.tracked_objects: + del self.tracked_objects[obj_id] + + # Remove from propagation results + for frame_results in self.propagation_results.values(): + if obj_id in frame_results: + del frame_results[obj_id] + + # Remove from list + row = self.left_panel.tracked_objects_list.row(current_item) + self.left_panel.tracked_objects_list.takeItem(row) + + # Refresh display + self.load_current_frame() + + QMessageBox.information(self, "Success", f"Object {obj_id} removed") + + except (ValueError, IndexError): + QMessageBox.warning(self, "Error", "Could not parse object ID") + + def propagate_forward_sam2(self): + """Propagate tracking forward using SAM2""" + if not self.video_tracking_enabled or not self.tracked_objects: + QMessageBox.warning( + self, "Error", "No tracking initialized or objects to track" + ) + return + + self.left_panel.tracking_progress.setVisible(True) + self.sam2_worker.propagate_video( + start_frame=self.current_frame_idx, reverse=False + ) + + def propagate_backward_sam2(self): + """Propagate tracking backward using SAM2""" + if not self.video_tracking_enabled or not self.tracked_objects: + QMessageBox.warning( + self, "Error", "No tracking initialized or objects to track" + ) + return + + self.left_panel.tracking_progress.setVisible(True) + self.sam2_worker.propagate_video( + start_frame=self.current_frame_idx, reverse=True + ) + + def clear_all_tracking(self): + """Clear all SAM2 tracking""" + if self.video_tracking_enabled: + self.sam2_worker.reset_tracking() + self.tracked_objects.clear() + self.propagation_results.clear() + self.next_object_id = 0 + + # Clear tracked objects list + if hasattr(self.left_panel, "tracked_objects_list"): + self.left_panel.tracked_objects_list.clear() + + # Refresh display + self.load_current_frame() + + self.left_panel.tracking_status_label.setText("All tracking cleared") + QMessageBox.information(self, "Success", "All tracking cleared") + + def on_object_selection_changed(self): + """Handle tracked object selection change""" + # Enable/disable remove button based on selection + has_selection = self.left_panel.tracked_objects_list.currentItem() is not None + self.left_panel.remove_object_btn.setEnabled(has_selection) + + def on_point_clicked(self, x: int, y: int, label: int): + """Handle point clicked in frame viewer""" + # Add point to frame viewer + self.frame_viewer.add_point(x, y, label) + + def on_sam2_model_loaded(self, success: bool, message: str): + """Handle SAM2 model loading completion""" + if success: + self.left_panel.tracking_status_label.setText( + "SAM2 model loaded successfully" + ) + print("SAM2 model loaded successfully") + else: + self.left_panel.tracking_status_label.setText( + f"SAM2 model loading failed: {message}" + ) + QMessageBox.critical( + self, "Model Loading Error", f"Failed to load SAM2 model: {message}" + ) + + def on_video_initialized(self, success: bool, message: str): + """Handle video initialization completion""" + self.left_panel.tracking_progress.setVisible(False) + + if success: + self.video_tracking_enabled = True + self.left_panel.tracking_status_label.setText("Video tracking initialized") + + # Enable tracking controls + self.left_panel.add_object_btn.setEnabled(True) + self.left_panel.clear_tracking_btn.setEnabled(True) + + print("Video tracking initialized successfully") + else: + self.left_panel.tracking_status_label.setText( + f"Video initialization failed: {message}" + ) + QMessageBox.critical( + self, + "Video Initialization Error", + f"Failed to initialize video: {message}", + ) + + def on_object_added(self, obj_id: int, object_info: dict): + """Handle object addition completion""" + try: + frame_idx = object_info["frame_idx"] + mask = object_info["mask"] + + # Store the mask for this object + if obj_id in self.tracked_objects: + self.tracked_objects[obj_id]["masks"][frame_idx] = mask + + # Add to tracked objects list + class_name = self.tracked_objects[obj_id]["class_name"] + item_text = f"Object {obj_id}: {class_name}" + self.left_panel.tracked_objects_list.addItem(item_text) + + # Enable propagation controls + self.left_panel.propagate_forward_btn.setEnabled(True) + self.left_panel.propagate_backward_btn.setEnabled(True) + + # Clear points and refresh display + self.frame_viewer.clear_points() + self.load_current_frame() + + self.left_panel.tracking_status_label.setText( + f"Object {obj_id} added successfully" + ) + print(f"Object {obj_id} added successfully to frame {frame_idx}") + else: + print(f"Warning: Object {obj_id} is missing from tracked_objects") + + except Exception as e: + QMessageBox.warning(self, "Error", f"Failed to process added object: {e}") + print(f"Error in on_object_added: {e}") + + def on_propagation_progress(self, frame_idx: int, progress: int): + """Handle propagation progress updates""" + self.left_panel.tracking_progress.setValue(progress) + self.left_panel.tracking_status_label.setText( + f"Propagating... Frame {frame_idx} ({progress}%)" + ) + + def on_propagation_complete(self, results): + """Handle propagation completion""" + self.left_panel.tracking_progress.setVisible(False) + + # Store propagation results + self.propagation_results.update(results) + + # Also store in tracked objects + for frame_idx, frame_results in results.items(): + for obj_id, mask in frame_results.items(): + if obj_id in self.tracked_objects: + self.tracked_objects[obj_id]["masks"][frame_idx] = mask + + # Refresh current frame display + self.load_current_frame() + + num_frames = len(results) + num_objects = len( + set( + obj_id + for frame_results in results.values() + for obj_id in frame_results.keys() + ) + ) + + self.left_panel.tracking_status_label.setText( + f"Propagation complete: {num_frames} frames, {num_objects} objects" + ) + print(f"Propagation complete: {num_frames} frames processed") + + def on_sam2_error(self, error_message: str): + """Handle SAM2 worker errors""" + self.left_panel.tracking_progress.setVisible(False) + self.left_panel.tracking_status_label.setText(f"Error: {error_message}") + QMessageBox.critical( + self, "SAM2 Error", f"SAM2 operation failed: {error_message}" + ) + print(f"SAM2 Error: {error_message}") diff --git a/data_engine/gui/sam2_video_worker.py b/data_engine/gui/sam2_video_worker.py index ddd31b8..2660666 100644 --- a/data_engine/gui/sam2_video_worker.py +++ b/data_engine/gui/sam2_video_worker.py @@ -195,6 +195,27 @@ def _add_object(self): obj_idx = obj_ids.index(data["obj_id"]) mask = video_res_masks[obj_idx].cpu().numpy() + print( + f"SAM2 mask shape: {mask.shape}, dtype: {mask.dtype}, min: {mask.min()}, max: {mask.max()}" + ) + + # Ensure mask is in the correct format (2D boolean/binary) + if mask.ndim > 2: + mask = mask.squeeze() + if mask.ndim != 2: + raise ValueError(f"Mask has invalid dimensions: {mask.shape}") + + # Convert to binary mask if needed + if mask.dtype == np.bool_: + # Already boolean, convert to uint8 for consistency + mask = mask.astype(np.uint8) * 255 + elif mask.max() <= 1.0: + # Floating point mask, threshold and convert + mask = (mask > 0.5).astype(np.uint8) * 255 + else: + # Already in uint8 range + mask = mask.astype(np.uint8) + object_info = { "obj_id": data["obj_id"], "frame_idx": frame_idx, @@ -235,6 +256,27 @@ def _propagate(self): frame_results = {} for i, obj_id in enumerate(obj_ids): mask = video_res_masks[i].cpu().numpy() + + # Ensure mask is in the correct format (2D boolean/binary) + if mask.ndim > 2: + mask = mask.squeeze() + if mask.ndim != 2: + print( + f"Warning: Mask for obj {obj_id} has invalid dimensions: {mask.shape}" + ) + continue + + # Convert to binary mask if needed + if mask.dtype == np.bool_: + # Already boolean, convert to uint8 for consistency + mask = mask.astype(np.uint8) * 255 + elif mask.max() <= 1.0: + # Floating point mask, threshold and convert + mask = (mask > 0.5).astype(np.uint8) * 255 + else: + # Already in uint8 range + mask = mask.astype(np.uint8) + frame_results[obj_id] = mask all_results[frame_idx] = frame_results diff --git a/data_engine/requirements.txt b/data_engine/requirements.txt index e0c2b04..3ed3f4f 100644 --- a/data_engine/requirements.txt +++ b/data_engine/requirements.txt @@ -10,3 +10,4 @@ tqdm>=4.64.0 hydra-core>=1.3.0 iopath>=0.1.9 fvcore>=0.1.5 +eva-decord>=0.6.1 From 8d7022e4c43f57e540140d8f789f0fb15abcd6bf Mon Sep 17 00:00:00 2001 From: Cruiz102 Date: Thu, 7 Aug 2025 02:51:03 -0400 Subject: [PATCH 7/8] this will going to be deprecated :v --- data_engine/Dockerfile | 7 +-- data_engine/README.md | 15 +++--- data_engine/gui/README.md | 2 +- data_engine/gui/left_panel.py | 13 +----- data_engine/gui/main_window.py | 70 +++++++--------------------- data_engine/gui/sam2_video_worker.py | 2 +- data_engine/test_imports.py | 8 +++- hocker | 2 +- hydrus-cli | 3 -- 9 files changed, 37 insertions(+), 85 deletions(-) diff --git a/data_engine/Dockerfile b/data_engine/Dockerfile index 5a2209a..b6183f5 100644 --- a/data_engine/Dockerfile +++ b/data_engine/Dockerfile @@ -73,12 +73,7 @@ checkpoint_urls = { \ [urllib.request.urlretrieve(url, f'/app/sam2_models/{filename}') for filename, url in checkpoint_urls.items() if not os.path.exists(f'/app/sam2_models/{filename}')]; \ print('All SAM2 models downloaded')" -# Download Ultralytics SAM models during build time -RUN python -c "from ultralytics import SAM; model = SAM('sam2_b.pt'); print('SAM2 base model downloaded')" -RUN python -c "from ultralytics import SAM; model = SAM('sam2_l.pt'); print('SAM2 large model downloaded')" -RUN python -c "from ultralytics import SAM; model = SAM('sam2_s.pt'); print('SAM2 small model downloaded')" - -# Download YOLOv8 models during build time +# Download YOLOv8 models during build time (keeping YOLO for dataset export) RUN python -c "from ultralytics import YOLO; model = YOLO('yolov8n.pt'); print('YOLOv8 nano model downloaded')" RUN python -c "from ultralytics import YOLO; model = YOLO('yolov8s.pt'); print('YOLOv8 small model downloaded')" RUN python -c "from ultralytics import YOLO; model = YOLO('yolov8m.pt'); print('YOLOv8 medium model downloaded')" diff --git a/data_engine/README.md b/data_engine/README.md index cf51d78..ce9d146 100644 --- a/data_engine/README.md +++ b/data_engine/README.md @@ -5,7 +5,7 @@ An automatic data engine GUI application that uses visual prompts to interact wi ## Features - **Interactive GUI**: Built with PySide6 for modern and intuitive user experience -- **SAM2 Integration**: Uses Ultralytics SAM2 for automatic segmentation +- **SAM2 Integration**: Uses native SAM2 for automatic segmentation - **Video Navigation**: Move back and forth through video frames - **Point-based Prompting**: Add positive/negative points for precise segmentation - **Automatic Propagation**: Forward and backward mask propagation across frames @@ -21,7 +21,6 @@ An automatic data engine GUI application that uses visual prompts to interact wi - OpenCV - NumPy - PyTorch -- Ultralytics (for SAM2) - Pillow ## Installation @@ -152,10 +151,11 @@ Where coordinates are normalized (0-1) polygon points. ## SAM2 Models -The application supports different SAM2 model sizes: -- `sam2_s.pt` - Small (fastest) -- `sam2_b.pt` - Base (balanced) -- `sam2_l.pt` - Large (most accurate) +The application uses native SAM2 model sizes: +- `sam2_hiera_tiny.pt` - Tiny (fastest) +- `sam2_hiera_small.pt` - Small (fast) +- `sam2_hiera_base_plus.pt` - Base Plus (balanced, default) +- `sam2_hiera_large.pt` - Large (most accurate) Models are automatically downloaded on first use. @@ -176,7 +176,7 @@ Models are automatically downloaded on first use. - Try different model sizes 2. **Memory Issues**: - - Use smaller SAM2 model (sam2_s.pt) + - Use smaller SAM2 model (sam2_hiera_tiny.pt) - Reduce video resolution - Clear cache regularly @@ -223,7 +223,6 @@ See the main Hydrus Software Stack license for details. ## References -- [Ultralytics SAM2 Documentation](https://docs.ultralytics.com/models/sam-2/) - [Segment Anything Model 2](https://github.com/facebookresearch/segment-anything-2) - [YOLO Format Specification](https://docs.ultralytics.com/datasets/segment/) diff --git a/data_engine/gui/README.md b/data_engine/gui/README.md index 3cb8318..de9fbc5 100644 --- a/data_engine/gui/README.md +++ b/data_engine/gui/README.md @@ -62,7 +62,7 @@ sys.exit(app.exec()) - OpenCV (cv2) for image processing - NumPy for array operations - PyTorch for tensor operations -- Ultralytics SAM for segmentation +- Native SAM2 for segmentation - pathlib for path handling ## Architecture diff --git a/data_engine/gui/left_panel.py b/data_engine/gui/left_panel.py index 0511b72..bce649b 100644 --- a/data_engine/gui/left_panel.py +++ b/data_engine/gui/left_panel.py @@ -103,8 +103,8 @@ def create_navigation_group(self) -> QGroupBox: return nav_group def create_sam_group(self) -> QGroupBox: - """Create SAM controls group""" - sam_group = QGroupBox("SAM2 Controls") + """Create SAM2 point controls group""" + sam_group = QGroupBox("SAM2 Point Controls") sam_layout = QVBoxLayout() # Point selection mode @@ -123,18 +123,9 @@ def create_sam_group(self) -> QGroupBox: self.clear_points_btn = QPushButton("Clear Points") self.segment_btn = QPushButton("Segment Object") - # Propagation controls - prop_layout = QHBoxLayout() - self.propagate_forward_btn = QPushButton("Propagate Forward") - self.propagate_backward_btn = QPushButton("Propagate Backward") - - prop_layout.addWidget(self.propagate_forward_btn) - prop_layout.addWidget(self.propagate_backward_btn) - sam_layout.addLayout(point_mode_layout) sam_layout.addWidget(self.clear_points_btn) sam_layout.addWidget(self.segment_btn) - sam_layout.addLayout(prop_layout) sam_group.setLayout(sam_layout) return sam_group diff --git a/data_engine/gui/main_window.py b/data_engine/gui/main_window.py index 0066a64..266e484 100644 --- a/data_engine/gui/main_window.py +++ b/data_engine/gui/main_window.py @@ -20,12 +20,6 @@ QWidget, ) -try: - from ultralytics import SAM -except ImportError: - print("Warning: ultralytics not installed. Limited functionality.") - SAM = None - # Import local modules from .frame_viewer import FrameViewer from .left_panel import LeftControlPanel @@ -47,7 +41,6 @@ def __init__(self): self.output_dir = None self.frames = [] self.current_frame_idx = 0 - self.sam_model = None self.frame_cache = {} self.masks_cache = {} self.annotations = {} # frame_idx: [annotations] @@ -65,7 +58,6 @@ def __init__(self): self.setup_ui() self.connect_signals() self.connect_sam2_signals() - self.load_sam_model() def setup_ui(self): """Setup the user interface""" @@ -148,21 +140,18 @@ def connect_sam2_signals(self): self.sam2_worker.error_occurred.connect(self.on_sam2_error) def load_sam_model(self): - """Load both SAM2 video model and fallback SAM model""" + """Load SAM2 video model""" try: # Load SAM2 video model for tracking + # TODO: Make this be loadable by the user. Let the user select the model it wants to use. self.sam2_worker.load_model("sam2_hiera_base_plus.pt") - - # Load fallback SAM model for single-frame segmentation - if SAM is not None: - self.sam_model = SAM("sam2_b.pt") # Use SAM2 base model - print("Fallback SAM model loaded successfully") + print("SAM2 video model loaded successfully") except Exception as e: - print(f"Warning: Failed to load models: {e}") + print(f"Warning: Failed to load SAM2 model: {e}") QMessageBox.warning( self, "Model Loading Warning", - f"Some models failed to load: {e}\nSome features may be limited.", + f"SAM2 model failed to load: {e}\nSome features may be limited.", ) def load_video(self): @@ -187,6 +176,7 @@ def load_video(self): def set_output_directory(self): """Set the output directory for the dataset""" + # TODO: This should have a default path, like the current working directory. dir_path = QFileDialog.getExistingDirectory(self, "Select Output Directory") if dir_path: @@ -428,15 +418,15 @@ def clear_points(self): self.frame_viewer.clear_points() def segment_current_frame(self): - """Segment current frame using SAM""" + """Segment current frame using SAM2""" if not self.frame_viewer.points: QMessageBox.warning( self, "Error", "Please click points on the object first" ) return - if self.sam_model is None: - QMessageBox.warning(self, "Error", "SAM model not loaded") + if self.sam2_worker.predictor is None: + QMessageBox.warning(self, "Error", "SAM2 model not loaded") return current_class_id = self.right_panel.class_manager.get_current_class_id() @@ -445,46 +435,22 @@ def segment_current_frame(self): return try: - # Get current frame - frame = self.frame_cache.get(self.current_frame_idx) - if frame is None: - QMessageBox.warning(self, "Error", "Frame not loaded") - return - - # Prepare points for SAM + # Prepare points for SAM2 points = np.array([[x, y] for x, y, _ in self.frame_viewer.points]) labels = np.array([label for _, _, label in self.frame_viewer.points]) - # Run SAM segmentation - results = self.sam_model(frame, points=points, labels=labels) - - if results and len(results) > 0: - masks = results[0].masks - if masks is not None: - # Get the best mask - mask = masks.data[0].cpu().numpy().astype(bool) + # Use SAM2 video worker for single frame segmentation + # Create a unique object ID for this segmentation + obj_id = len(self.annotations.get(self.current_frame_idx, [])) + 1 - # Store annotation - self.store_annotation( - self.current_frame_idx, mask, current_class_id - ) + # Add object to SAM2 for tracking + self.sam2_worker.add_object(self.current_frame_idx, points, labels, obj_id) - # Update display - color = self.get_class_color(current_class_id) - self.frame_viewer.add_mask(mask, color=color, alpha=0.4) - self.update_annotations_display() - - # Clear points - self.frame_viewer.clear_points() - - print(f"Segmentation completed for frame {self.current_frame_idx}") - else: - QMessageBox.warning(self, "Error", "No mask generated") - else: - QMessageBox.warning(self, "Error", "Segmentation failed") + # Note: The actual mask will be received via the object_added signal + # and processed in the corresponding slot method except Exception as e: - QMessageBox.critical(self, "Segmentation Error", f"Failed to segment: {e}") + QMessageBox.critical(self, "Error", f"Segmentation failed: {e}") def store_annotation(self, frame_idx: int, mask: np.ndarray, class_id: int): """Store annotation for a frame""" diff --git a/data_engine/gui/sam2_video_worker.py b/data_engine/gui/sam2_video_worker.py index 2660666..acca449 100644 --- a/data_engine/gui/sam2_video_worker.py +++ b/data_engine/gui/sam2_video_worker.py @@ -82,7 +82,7 @@ def stop_current_task(self): """Stop the current running task""" self.is_running = False - def run(self): + def run(self) -> None: """Execute the current task""" self.is_running = True try: diff --git a/data_engine/test_imports.py b/data_engine/test_imports.py index 01005e3..e7dbc27 100644 --- a/data_engine/test_imports.py +++ b/data_engine/test_imports.py @@ -22,9 +22,13 @@ print(f"✗ OpenCV: {e}") try: - from ultralytics import SAM + import importlib.util - print("✓ Ultralytics SAM") + ultralytics_spec = importlib.util.find_spec("ultralytics") + if ultralytics_spec is not None: + print("✓ Ultralytics (for YOLO only)") + else: + print("✗ Ultralytics: not found") except ImportError as e: print(f"✗ Ultralytics: {e}") diff --git a/hocker b/hocker index 20b74cc..474d715 120000 --- a/hocker +++ b/hocker @@ -1 +1 @@ -/home/catkin_ws/src/hydrus-software-stack/docker/hydrus-docker/hocker.py \ No newline at end of file +/home/cesar/Projects/hydrus-software-stack/docker/hydrus-docker/hocker.py \ No newline at end of file diff --git a/hydrus-cli b/hydrus-cli index 3074f4a..03199d0 100755 --- a/hydrus-cli +++ b/hydrus-cli @@ -5,9 +5,6 @@ # Get the directory where this wrapper is located (should be project root) SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" -# Set HYDRUS_ROOT environment variable to ensure test system works correctly -export HYDRUS_ROOT="$SCRIPT_DIR" - # Change to the project directory to ensure proper module resolution cd "$SCRIPT_DIR" From c2536f3558fbacdd4a6a1a374f5aa5ad54c01690 Mon Sep 17 00:00:00 2001 From: Cruiz102 Date: Sun, 17 Aug 2025 01:25:05 -0400 Subject: [PATCH 8/8] added readme how to run poc. Change folder structure. --- data_engine/README.md | 234 ------------------ data_engine/Readme.md | 3 + data_engine/{ => poc}/.dockerignore | 0 data_engine/{ => poc}/Dockerfile | 0 data_engine/poc/README.md | 30 +++ data_engine/{ => poc}/config.py | 0 data_engine/{ => poc}/docker-compose.yml | 0 data_engine/{ => poc}/gui/README.md | 0 data_engine/{ => poc}/gui/__init__.py | 0 data_engine/{ => poc}/gui/center_panel.py | 0 data_engine/{ => poc}/gui/frame_viewer.py | 0 data_engine/{ => poc}/gui/left_panel.py | 0 data_engine/{ => poc}/gui/main_window.py | 0 .../{ => poc}/gui/object_class_manager.py | 0 data_engine/{ => poc}/gui/right_panel.py | 0 .../{ => poc}/gui/sam2_video_worker.py | 0 data_engine/{ => poc}/gui/workers.py | 0 data_engine/{ => poc}/main.py | 0 data_engine/poc/poc_screenshot.png | Bin 0 -> 382327 bytes data_engine/{ => poc}/requirements.txt | 0 data_engine/{ => poc}/utils.py | 0 data_engine/{ => poc}/videos/example.mp4 | Bin data_engine/setup_x11.sh | 30 --- data_engine/test_imports.py | 73 ------ 24 files changed, 33 insertions(+), 337 deletions(-) delete mode 100644 data_engine/README.md create mode 100644 data_engine/Readme.md rename data_engine/{ => poc}/.dockerignore (100%) rename data_engine/{ => poc}/Dockerfile (100%) create mode 100644 data_engine/poc/README.md rename data_engine/{ => poc}/config.py (100%) rename data_engine/{ => poc}/docker-compose.yml (100%) rename data_engine/{ => poc}/gui/README.md (100%) rename data_engine/{ => poc}/gui/__init__.py (100%) rename data_engine/{ => poc}/gui/center_panel.py (100%) rename data_engine/{ => poc}/gui/frame_viewer.py (100%) rename data_engine/{ => poc}/gui/left_panel.py (100%) rename data_engine/{ => poc}/gui/main_window.py (100%) rename data_engine/{ => poc}/gui/object_class_manager.py (100%) rename data_engine/{ => poc}/gui/right_panel.py (100%) rename data_engine/{ => poc}/gui/sam2_video_worker.py (100%) rename data_engine/{ => poc}/gui/workers.py (100%) rename data_engine/{ => poc}/main.py (100%) create mode 100644 data_engine/poc/poc_screenshot.png rename data_engine/{ => poc}/requirements.txt (100%) rename data_engine/{ => poc}/utils.py (100%) rename data_engine/{ => poc}/videos/example.mp4 (100%) delete mode 100755 data_engine/setup_x11.sh delete mode 100644 data_engine/test_imports.py diff --git a/data_engine/README.md b/data_engine/README.md deleted file mode 100644 index ce9d146..0000000 --- a/data_engine/README.md +++ /dev/null @@ -1,234 +0,0 @@ -# SAM2 Data Engine - YOLO Dataset Generator - -An automatic data engine GUI application that uses visual prompts to interact with SAM2 (Segment Anything Model 2) for generating YOLO training datasets with automatic video segmentation. - -## Features - -- **Interactive GUI**: Built with PySide6 for modern and intuitive user experience -- **SAM2 Integration**: Uses native SAM2 for automatic segmentation -- **Video Navigation**: Move back and forth through video frames -- **Point-based Prompting**: Add positive/negative points for precise segmentation -- **Automatic Propagation**: Forward and backward mask propagation across frames -- **Smart Caching**: Cache frames, masks, and SAM2 features for faster processing -- **YOLO Export**: Export annotations in YOLO dataset format -- **Object Classification**: Assign class names to segmented objects -- **Real-time Visualization**: See segmentation results with overlay masks - -## Requirements - -- Python 3.8+ -- PySide6 -- OpenCV -- NumPy -- PyTorch -- Pillow - -## Installation - -### Option 1: Local Installation - -1. **Clone or navigate to the data_engine directory**: -```bash -cd /path/to/hydrus-software-stack/data_engine -``` - -2. **Install dependencies**: -```bash -pip install -r requirements.txt -``` - -3. **Run setup script** (optional - downloads SAM2 models): -```bash -python setup.py -``` - -4. **Launch the application**: -```bash -python main.py -``` - -### Option 2: Docker Installation (Recommended) - -1. **Setup X11 for GUI support**: -```bash -make docker-setup -``` - -2. **Build and run with Docker**: -```bash -make docker-build -make docker-run -``` - -3. **Alternative Docker commands**: -```bash -# Interactive shell -make docker-shell - -# Run tests -make docker-test -``` - -For detailed Docker setup, see [DOCKER.md](DOCKER.md). - -## Usage - -### 1. Load Video -- Click "Load Video" to select a video file -- Supported formats: MP4, AVI, MOV, MKV, WMV -- Set output directory for caching and exports - -### 2. Navigate Frames -- Use the slider or spinbox to navigate between frames -- Use "◀ Prev" and "Next ▶" buttons for frame-by-frame navigation -- Frames are automatically cached for faster access - -### 3. Add Object Classes -- In the right panel, add class names for your objects -- Each class gets a unique ID automatically -- Select a class before segmenting objects - -### 4. Segment Objects -- **Add Points**: Click on the frame to add positive (green) or negative (red) points -- **Positive Points**: Click inside the object you want to segment -- **Negative Points**: Click outside the object or on background -- **Segment**: Click "Segment Object" to run SAM2 segmentation -- **Clear Points**: Remove all points and start over - -### 5. Propagate Masks -- After segmenting an object, use propagation to track it across frames -- **Forward Propagation**: Tracks object in subsequent frames -- **Backward Propagation**: Tracks object in previous frames - -### 6. Export Dataset -- Click "Export YOLO Dataset" to save annotations -- Creates folder structure: `images/`, `labels/`, `classes.txt`, `dataset.yaml` -- Annotations are saved in YOLO segmentation format - -## Directory Structure - -``` -data_engine/ -├── main.py # Main GUI application -├── sam_processor.py # SAM2 integration module -├── utils.py # Utility functions -├── setup.py # Setup script -├── requirements.txt # Python dependencies -├── README.md # This file -├── cache/ # Cached data -│ ├── frames/ # Cached video frames -│ ├── masks/ # Cached segmentation masks -│ └── features/ # Cached SAM2 features -├── projects/ # Project configurations -└── exports/ # Exported datasets -``` - -## Output Format - -The tool exports datasets in YOLO format: - -### Dataset Structure -``` -yolo_dataset/ -├── images/ # Training images -│ ├── frame_000001.jpg -│ ├── frame_000002.jpg -│ └── ... -├── labels/ # Segmentation labels -│ ├── frame_000001.txt -│ ├── frame_000002.txt -│ └── ... -├── classes.txt # Class names -└── dataset.yaml # YOLO configuration -``` - -### Label Format -Each `.txt` file contains one line per object: -``` -class_id x1 y1 x2 y2 x3 y3 ... xn yn -``` -Where coordinates are normalized (0-1) polygon points. - -## SAM2 Models - -The application uses native SAM2 model sizes: -- `sam2_hiera_tiny.pt` - Tiny (fastest) -- `sam2_hiera_small.pt` - Small (fast) -- `sam2_hiera_base_plus.pt` - Base Plus (balanced, default) -- `sam2_hiera_large.pt` - Large (most accurate) - -Models are automatically downloaded on first use. - -## Performance Tips - -1. **Use GPU**: Ensure CUDA is available for faster inference -2. **Cache Features**: Enable feature caching for repeated processing -3. **Optimize Points**: Use minimal points for faster segmentation -4. **Batch Processing**: Process multiple frames at once when possible - -## Troubleshooting - -### Common Issues - -1. **Model Loading Error**: - - Ensure internet connection for model download - - Check CUDA/PyTorch compatibility - - Try different model sizes - -2. **Memory Issues**: - - Use smaller SAM2 model (sam2_hiera_tiny.pt) - - Reduce video resolution - - Clear cache regularly - -3. **Slow Performance**: - - Enable GPU acceleration - - Use feature caching - - Process frames in batches - -### System Requirements - -- **Minimum**: 8GB RAM, CPU-only -- **Recommended**: 16GB+ RAM, NVIDIA GPU with 6GB+ VRAM -- **For Large Videos**: 32GB+ RAM, High-end GPU - -## Advanced Features - -### Custom Prompting -- Combine point and box prompts for complex objects -- Use multiple positive/negative points for precision -- Adjust SAM2 parameters for different object types - -### Batch Processing -- Process multiple videos sequentially -- Export datasets in different formats -- Automated quality control and validation - -### Integration -- Export to other annotation formats (COCO, Pascal VOC) -- Integration with training pipelines -- Custom post-processing workflows - -## Contributing - -This tool is part of the Hydrus Software Stack. For contributions: - -1. Follow the existing code structure -2. Add tests for new features -3. Update documentation -4. Ensure compatibility with SAM2 updates - -## License - -See the main Hydrus Software Stack license for details. - -## References - -- [Segment Anything Model 2](https://github.com/facebookresearch/segment-anything-2) -- [YOLO Format Specification](https://docs.ultralytics.com/datasets/segment/) - -## Support - -For issues and questions: -1. Check the troubleshooting section -2. Review SAM2 documentation -3. Open an issue in the main repository diff --git a/data_engine/Readme.md b/data_engine/Readme.md new file mode 100644 index 0000000..ec28c61 --- /dev/null +++ b/data_engine/Readme.md @@ -0,0 +1,3 @@ +# Data Engine + +For now we have a POC of the project. Data engine is in progress of development. diff --git a/data_engine/.dockerignore b/data_engine/poc/.dockerignore similarity index 100% rename from data_engine/.dockerignore rename to data_engine/poc/.dockerignore diff --git a/data_engine/Dockerfile b/data_engine/poc/Dockerfile similarity index 100% rename from data_engine/Dockerfile rename to data_engine/poc/Dockerfile diff --git a/data_engine/poc/README.md b/data_engine/poc/README.md new file mode 100644 index 0000000..a7b16ec --- /dev/null +++ b/data_engine/poc/README.md @@ -0,0 +1,30 @@ +# SAM2 Data Engine - YOLO Dataset Generator + +An automatic data engine GUI application that uses visual prompts to interact with SAM2 (Segment Anything Model 2) for generating YOLO training datasets with automatic video segmentation. + + + +This implementation is a POC of the actual data engine that we want to build. It should serve as reference as the type of features we want to have. + + +### How to run this code? + +It has a dockerfile to run the application. + +First give access for the docker access the xserver with this command: + +```bash +xhost + +``` + + +Then run docker container with compose. Inside the directory run the following command: + +```bash +docker compose up +``` + +You should see the following applicatation running. + + +![](poc_screenshot.png) diff --git a/data_engine/config.py b/data_engine/poc/config.py similarity index 100% rename from data_engine/config.py rename to data_engine/poc/config.py diff --git a/data_engine/docker-compose.yml b/data_engine/poc/docker-compose.yml similarity index 100% rename from data_engine/docker-compose.yml rename to data_engine/poc/docker-compose.yml diff --git a/data_engine/gui/README.md b/data_engine/poc/gui/README.md similarity index 100% rename from data_engine/gui/README.md rename to data_engine/poc/gui/README.md diff --git a/data_engine/gui/__init__.py b/data_engine/poc/gui/__init__.py similarity index 100% rename from data_engine/gui/__init__.py rename to data_engine/poc/gui/__init__.py diff --git a/data_engine/gui/center_panel.py b/data_engine/poc/gui/center_panel.py similarity index 100% rename from data_engine/gui/center_panel.py rename to data_engine/poc/gui/center_panel.py diff --git a/data_engine/gui/frame_viewer.py b/data_engine/poc/gui/frame_viewer.py similarity index 100% rename from data_engine/gui/frame_viewer.py rename to data_engine/poc/gui/frame_viewer.py diff --git a/data_engine/gui/left_panel.py b/data_engine/poc/gui/left_panel.py similarity index 100% rename from data_engine/gui/left_panel.py rename to data_engine/poc/gui/left_panel.py diff --git a/data_engine/gui/main_window.py b/data_engine/poc/gui/main_window.py similarity index 100% rename from data_engine/gui/main_window.py rename to data_engine/poc/gui/main_window.py diff --git a/data_engine/gui/object_class_manager.py b/data_engine/poc/gui/object_class_manager.py similarity index 100% rename from data_engine/gui/object_class_manager.py rename to data_engine/poc/gui/object_class_manager.py diff --git a/data_engine/gui/right_panel.py b/data_engine/poc/gui/right_panel.py similarity index 100% rename from data_engine/gui/right_panel.py rename to data_engine/poc/gui/right_panel.py diff --git a/data_engine/gui/sam2_video_worker.py b/data_engine/poc/gui/sam2_video_worker.py similarity index 100% rename from data_engine/gui/sam2_video_worker.py rename to data_engine/poc/gui/sam2_video_worker.py diff --git a/data_engine/gui/workers.py b/data_engine/poc/gui/workers.py similarity index 100% rename from data_engine/gui/workers.py rename to data_engine/poc/gui/workers.py diff --git a/data_engine/main.py b/data_engine/poc/main.py similarity index 100% rename from data_engine/main.py rename to data_engine/poc/main.py diff --git a/data_engine/poc/poc_screenshot.png b/data_engine/poc/poc_screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..6320292547faaa51794512d36cc5f9921587b6de GIT binary patch literal 382327 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

u(e(s@0I8p<$}k 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

0+tb7YMLj~?PP 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