diff --git a/PLAN_SUMMARY.md b/PLAN_SUMMARY.md new file mode 100644 index 0000000..97ac04f --- /dev/null +++ b/PLAN_SUMMARY.md @@ -0,0 +1,323 @@ +# Project Plan Summary - Microscopy Object Detection Application + +## Executive Summary + +This document provides a high-level overview of the planned microscopy object detection application. The application will enable users to train, validate, and deploy YOLOv8-based object detection models for microscopy images, with comprehensive GUI, database storage, and visualization capabilities. + +## Project Goals + +1. **Detect Objects**: Identify organelles and membrane branching structures in microscopy images +2. **Train Models**: Fine-tune YOLOv8s on custom datasets with YOLO format annotations +3. **Manage Results**: Store and query detection results in SQLite database +4. **Visualize Data**: Interactive plots and image viewers for analysis +5. **Export Results**: Flexible export options (CSV, JSON, Excel) +6. **Future Annotation**: Provide manual annotation capabilities for dataset preparation + +## Key Technologies + +| Component | Technology | Purpose | +|-----------|------------|---------| +| ML Framework | Ultralytics YOLOv8 | Object detection model | +| GUI | PySide6 | Desktop application interface | +| Visualization | pyqtgraph | Real-time plots and charts | +| Database | SQLite | Detection results storage | +| Image Processing | OpenCV, Pillow | Image manipulation | + +## Application Architecture + +### Three-Layer Architecture + +``` +┌─────────────────────────────────────┐ +│ GUI Layer (PySide6) │ +│ - Main Window with Tabs │ +│ - Dialogs & Custom Widgets │ +└──────────────┬──────────────────────┘ + │ +┌──────────────▼──────────────────────┐ +│ Business Logic Layer │ +│ - YOLO Wrapper │ +│ - Inference Engine │ +│ - Database Manager │ +│ - Config Manager │ +└──────────────┬──────────────────────┘ + │ +┌──────────────▼──────────────────────┐ +│ Data Layer │ +│ - SQLite Database │ +│ - File System (images, models) │ +│ - YOLOv8 Model Files │ +└─────────────────────────────────────┘ +``` + +## Core Features + +### 1. Detection Tab ✨ +- **Single Image Detection**: Select and detect objects in one image +- **Batch Processing**: Process entire folders of images +- **Real-time Preview**: View detections with bounding boxes +- **Confidence Control**: Adjustable threshold slider +- **Database Storage**: Automatic saving of results with metadata + +### 2. Training Tab 🎓 +- **Dataset Selection**: Browse for YOLO format datasets +- **Parameter Configuration**: Epochs, batch size, image size, learning rate +- **Progress Monitoring**: Real-time training metrics and loss curves +- **Model Versioning**: Automatic model naming and version tracking +- **Validation Metrics**: Track mAP, precision, recall during training + +### 3. Validation Tab 📊 +- **Model Evaluation**: Validate models on test datasets +- **Metrics Visualization**: + - Confusion matrix + - Precision-Recall curves + - Class-wise performance +- **Model Comparison**: Compare multiple model versions + +### 4. Results Tab 📈 +- **Detection Browser**: Searchable table of all detections +- **Advanced Filtering**: By date, model, class, confidence +- **Statistics Dashboard**: + - Detection count by class + - Confidence distribution + - Timeline visualization +- **Export Options**: CSV, JSON, Excel formats + +### 5. Annotation Tab 🖊️ (Future Feature) +- **Image Browser**: Navigate through image repository +- **Drawing Tools**: Create bounding boxes +- **Class Assignment**: Label objects +- **YOLO Export**: Export annotations for training + +## Database Design + +### Tables Overview + +| Table | Purpose | Key Fields | +|-------|---------|------------| +| **models** | Store trained models | name, version, path, metrics | +| **images** | Image metadata | path, dimensions, checksum | +| **detections** | Detection results | bbox, class, confidence | +| **annotations** | Manual labels | bbox, class, annotator | + +### Key Relationships +- Each detection links to one image and one model +- Each image can have multiple detections from multiple models +- Annotations are separate from automated detections + +## Implementation Phases + +### Phase 1: Core Foundation (Weeks 1-2) +- [x] Architecture design and documentation +- [ ] Project structure setup +- [ ] Database schema implementation +- [ ] YOLO wrapper basic functionality +- [ ] Database manager CRUD operations + +### Phase 2: GUI Development (Weeks 3-4) +- [ ] Main window and tab structure +- [ ] Detection tab implementation +- [ ] Training tab implementation +- [ ] Basic visualization widgets +- [ ] Configuration management + +### Phase 3: Advanced Features (Weeks 5-6) +- [ ] Validation tab with metrics +- [ ] Results tab with filtering +- [ ] Export functionality +- [ ] Error handling and logging +- [ ] Performance optimization + +### Phase 4: Polish & Testing (Week 7) +- [ ] Unit tests for all components +- [ ] Integration testing +- [ ] User documentation +- [ ] Bug fixes and refinements +- [ ] Deployment preparation + +### Phase 5: Future Enhancements (Post-Launch) +- [ ] Annotation tool +- [ ] Real-time camera detection +- [ ] Multi-model ensemble +- [ ] Cloud integration + +## File Structure + +``` +object_detection/ +├── main.py # Entry point +├── requirements.txt # Dependencies +├── README.md # User documentation +├── ARCHITECTURE.md # Technical architecture +├── IMPLEMENTATION_GUIDE.md # Development guide +├── PLAN_SUMMARY.md # This file +│ +├── config/ +│ └── app_config.yaml # Application settings +│ +├── src/ +│ ├── database/ # Database layer +│ │ ├── db_manager.py # Main database operations +│ │ ├── models.py # Data classes +│ │ └── schema.sql # SQL schema +│ │ +│ ├── model/ # ML layer +│ │ ├── yolo_wrapper.py # YOLO interface +│ │ └── inference.py # Detection engine +│ │ +│ ├── gui/ # Presentation layer +│ │ ├── main_window.py # Main app window +│ │ ├── tabs/ # Feature tabs +│ │ ├── dialogs/ # Popup dialogs +│ │ └── widgets/ # Custom widgets +│ │ +│ └── utils/ # Utilities +│ ├── config_manager.py # Config handling +│ ├── logger.py # Logging setup +│ └── file_utils.py # File operations +│ +├── data/ # Runtime data +│ ├── models/ # Trained models +│ ├── datasets/ # Training data +│ └── results/ # Detection outputs +│ +├── tests/ # Test suite +│ ├── test_database.py +│ ├── test_model.py +│ └── test_gui.py +│ +├── logs/ # Application logs +└── docs/ # Additional docs +``` + +## User Workflows + +### Workflow 1: First-Time Setup +1. Launch application +2. Configure image repository path in Settings +3. Download/verify YOLOv8s.pt base model +4. Ready to detect! + +### Workflow 2: Quick Detection +1. Open Detection tab +2. Select pre-trained model +3. Choose image or folder +4. Adjust confidence threshold +5. Click "Detect" +6. View results and save to database + +### Workflow 3: Train Custom Model +1. Prepare dataset in YOLO format +2. Open Training tab +3. Select data.yaml file +4. Configure hyperparameters +5. Start training +6. Monitor progress +7. Model saved automatically with metrics + +### Workflow 4: Analyze Results +1. Open Results tab +2. Apply filters (date range, class, model) +3. View statistics dashboard +4. Export filtered results to CSV/JSON + +## Data Formats + +### YOLO Annotation Format +``` + +``` +- All coordinates normalized (0-1) +- One line per object +- Separate .txt file for each image + +### Detection Output Format +```json +{ + "image_id": 123, + "image_path": "relative/path/to/image.jpg", + "model_id": 5, + "model_name": "organelle_detector_v1", + "detections": [ + { + "class_name": "organelle", + "confidence": 0.95, + "bbox": [0.1, 0.2, 0.3, 0.4], + "detected_at": "2024-12-04T15:30:00Z" + } + ] +} +``` + +## Performance Requirements + +| Metric | Target | Notes | +|--------|--------|-------| +| Detection Speed | < 1s per image | On GPU for 640x640 images | +| Training Start | < 5s | Model loading time | +| Database Query | < 100ms | For 10k detections | +| GUI Responsiveness | < 100ms | UI interactions | +| Memory Usage | < 4GB | During inference | +| Batch Processing | 100+ images | Without memory issues | + +## Risk Mitigation + +| Risk | Impact | Mitigation Strategy | +|------|--------|-------------------| +| CUDA/GPU issues | High | Fallback to CPU mode | +| Database corruption | Medium | Regular backups, transactions | +| Large datasets | Medium | Lazy loading, pagination | +| Memory overflow | High | Batch size limits, monitoring | +| Model compatibility | Low | Version checking, validation | + +## Success Criteria + +- ✅ Successfully detect objects in microscopy images +- ✅ Train custom models with >80% mAP50 +- ✅ Store and retrieve detection results efficiently +- ✅ Intuitive GUI requiring minimal training +- ✅ Process 100+ images in batch mode +- ✅ Export results in multiple formats +- ✅ Comprehensive documentation + +## Next Steps + +1. **Review this plan** with stakeholders +2. **Gather feedback** on features and priorities +3. **Confirm requirements** are fully captured +4. **Switch to Code mode** to begin implementation +5. **Follow the implementation guide** for development +6. **Iterate based on testing** and user feedback + +## Questions for Stakeholders + +Before proceeding to implementation, please consider: + +1. Are there any additional object classes beyond organelles and membrane branches? +2. What is the typical size of your microscopy images? +3. Do you need multi-user support or is single-user sufficient? +4. Are there specific export formats you need beyond CSV/JSON/Excel? +5. What is your expected dataset size (number of images)? +6. Do you need support for 3D/volumetric microscopy images? +7. Any specific visualization requirements? +8. Integration with other tools or workflows? + +## Resources Required + +### Development Time +- Phase 1-3: ~6 weeks development +- Phase 4: ~1 week testing & polish +- Total: ~7 weeks for initial release + +### Hardware Requirements +- Development machine with CUDA GPU (recommended) +- 16GB RAM minimum +- 50GB storage for development + +### Software Dependencies +- All listed in [`requirements.txt`](requirements.txt) +- Total size: ~2GB when installed + +--- + +**Ready to proceed with implementation? Let's build this! 🚀** \ No newline at end of file diff --git a/main.py b/main.py new file mode 100644 index 0000000..77b6a30 --- /dev/null +++ b/main.py @@ -0,0 +1,54 @@ +""" +Microscopy Object Detection Application +Main entry point for the application. +""" + +import sys +from pathlib import Path + +# Add src directory to path +sys.path.insert(0, str(Path(__file__).parent)) + +from PySide6.QtWidgets import QApplication +from PySide6.QtCore import Qt + +from src.gui.main_window import MainWindow +from src.utils.logger import setup_logging +from src.utils.config_manager import ConfigManager + + +def main(): + """Application entry point.""" + # Setup logging + config_manager = ConfigManager() + log_config = config_manager.get_section("logging") + setup_logging( + log_file=log_config.get("file", "logs/app.log"), + level=log_config.get("level", "INFO"), + log_format=log_config.get("format"), + ) + + # Enable High DPI scaling + QApplication.setHighDpiScaleFactorRoundingPolicy( + Qt.HighDpiScaleFactorRoundingPolicy.PassThrough + ) + + # Create Qt application + app = QApplication(sys.argv) + app.setApplicationName("Microscopy Object Detection") + app.setOrganizationName("MicroscopyLab") + app.setApplicationVersion("1.0.0") + + # Set application style + app.setStyle("Fusion") + + # Create and show main window + window = MainWindow() + window.show() + + # Run application + sys.exit(app.exec()) + + +if __name__ == "__main__": + main()