martin/object-segmentation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adding documentation and main.py

Browse Source
This commit is contained in:
Martin Laasmaa
2025-12-05 09:44:00 +02:00
parent ce9e6af685
commit c6143cd11a
2 changed files with 377 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

323
PLAN_SUMMARY.md Normal file
View File

@@ -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
```
<class_id> <x_center> <y_center> <width> <height>
```
- 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! 🚀**

54
main.py Normal file
View File

@@ -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()