Add missing important files: _app_.py, utils/, CVAT_download/, manifest.json, and documentation

CVAT_download/download.py

@@ -0,0 +1,164 @@
+from cvat_sdk import make_client
+from cvat_sdk.core.client import Config
+import os
+from pathlib import Path
+import urllib3
+
+# Disable SSL warnings for self-signed certificates
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+HOST = "http://134.76.21.30:8080"
+USERNAME = "XXXXXX"
+PASSWORD = "XXXXXXX"
+PROJECT_ID = 7
+
+# Base output directory
+OUTPUT_ROOT = Path(f"cvat_project_{PROJECT_ID}_export")
+
+def main():
+    OUTPUT_ROOT.mkdir(parents=True, exist_ok=True)
+
+    # Connect to CVAT
+    with make_client(HOST, credentials=(USERNAME, PASSWORD)) as client:
+        # Disable SSL verification - CVAT returns HTTPS URLs for downloads even when connecting via HTTP
+        client.config.verify_ssl = False
+        # Optional: if you use organizations, set it here:
+        # client.config.org_slug = "eManusKript"
+
+        project = client.projects.retrieve(PROJECT_ID)
+        print(f"Project: {project.name} (ID={project.id})")
+
+        # Get all tasks belonging to this project
+        tasks = project.get_tasks()
+        print(f"Found {len(tasks)} tasks in project {PROJECT_ID}")
+
+        for t in tasks:
+            task_id = t.id
+            task_name = t.name
+            task_name_sanitized = "".join(c if c.isalnum() or c in "-_ " else "_" for c in task_name)
+            task_dir = OUTPUT_ROOT / f"task_{task_id}_{task_name_sanitized}"
+            task_dir.mkdir(parents=True, exist_ok=True)
+
+            print(f"\n=== Task {task_id}: {task_name} ===")
+
+            # Retrieve the full Task proxy object (not just TaskRead model)
+            task = client.tasks.retrieve(task_id)
+
+            # 1) Download images with original filenames
+            images_dir = task_dir / "images"
+            images_dir.mkdir(exist_ok=True)
+            
+            from PIL import Image
+            from io import BytesIO
+            
+            # Get frames info
+            frames_info = task.get_frames_info()
+            if not frames_info:
+                print(f"  No frames found in task {task_id}")
+            else:
+                # Check if images already downloaded
+                existing_images = list(images_dir.glob("*"))
+                if len(existing_images) == len(frames_info):
+                    print(f"  Images already exist in {images_dir} ({len(frames_info)} images)")
+                else:
+                    print(f"  Downloading {len(frames_info)} images to {images_dir} ...")
+                    
+                    for idx, frame_info in enumerate(frames_info):
+                        frame_id = idx  # Frame IDs are 0-indexed
+                        # frame_info is a dict with 'name', 'height', 'width', etc.
+                        original_name = frame_info.get('name', f'frame_{frame_id:06d}.jpg')
+                        # Ensure we have an extension
+                        if '.' not in original_name:
+                            original_name += '.jpg'
+                        
+                        output_path = images_dir / original_name
+                        if output_path.exists():
+                            continue
+                        
+                        try:
+                            frame_bytes = task.get_frame(frame_id, quality="original")
+                            # get_frame returns a response object, read it
+                            img_data = frame_bytes.read()
+                            img = Image.open(BytesIO(img_data))
+                            img.save(output_path)
+                            if (idx + 1) % 10 == 0 or (idx + 1) == len(frames_info):
+                                print(f"    Downloaded {idx + 1}/{len(frames_info)} images...")
+                        except Exception as e:
+                            print(f"    Error downloading frame {frame_id} ({original_name}): {e}")
+
+            # 2) Export annotations in COCO 1.0 (without images since we download them separately)
+            anno_zip = task_dir / f"task_{task_id}_coco1.0.zip"
+            if not anno_zip.exists():
+                print(f"  Exporting COCO 1.0 annotations to {anno_zip} ...")
+                # Replace pool manager BEFORE export_dataset call to handle HTTPS downloads
+                import ssl
+                from urllib3.poolmanager import PoolManager
+                from cvat_sdk.core.downloading import Downloader
+                
+                old_pool = client.api_client.rest_client.pool_manager
+                # Replace pool manager to disable SSL verification for HTTPS downloads
+                client.api_client.rest_client.pool_manager = PoolManager(
+                    cert_reqs=ssl.CERT_NONE
+                )
+                try:
+                    # Use the downloader directly to have more control
+                    downloader = Downloader(client)
+                    
+                    # Prepare the export using the same endpoint as export_dataset
+                    print(f"    Preparing export...")
+                    export_request = downloader.prepare_file(
+                        task.api.create_dataset_export_endpoint,
+                        url_params={"id": task_id},
+                        query_params={
+                            "format": "COCO 1.0",
+                            "save_images": "false"
+                        }
+                    )
+                    
+                    if not export_request.result_url:
+                        raise Exception("Export completed but no result URL returned")
+                    
+                    # Convert HTTPS URL to HTTP if needed
+                    result_url = export_request.result_url
+                    if result_url.startswith("https://"):
+                        result_url = result_url.replace("https://", "http://", 1)
+                        print(f"    Converted HTTPS URL to HTTP: {result_url[:80]}...")
+                    
+                    # Download the file
+                    print(f"    Downloading from result URL...")
+                    downloader.download_file(result_url, output_path=Path(anno_zip))
+                    print(f"    Successfully downloaded annotations")
+                    
+                except Exception as e:
+                    print(f"  Error exporting annotations: {e}")
+                    import traceback
+                    traceback.print_exc()
+                    # Try with images included as fallback
+                    print(f"  Retrying with images included...")
+                    try:
+                        export_request = downloader.prepare_file(
+                            task.api.create_dataset_export_endpoint,
+                            url_params={"id": task_id},
+                            query_params={
+                                "format": "COCO 1.0",
+                                "save_images": "true"
+                            }
+                        )
+                        result_url = export_request.result_url
+                        if result_url and result_url.startswith("https://"):
+                            result_url = result_url.replace("https://", "http://", 1)
+                        downloader.download_file(result_url, output_path=Path(anno_zip))
+                        print(f"    Successfully downloaded annotations with images")
+                    except Exception as e2:
+                        print(f"  Failed again: {e2}")
+                        raise
+                finally:
+                    # Restore original pool manager after export completes
+                    client.api_client.rest_client.pool_manager = old_pool
+            else:
+                print(f"  Annotations already exist: {anno_zip}")
+
+    print(f"\nDone. All data saved under: {OUTPUT_ROOT.resolve()}")
+
+if __name__ == "__main__":
+    main()

CVAT_download/unzip.py

@@ -0,0 +1,29 @@
+import os
+import zipfile
+
+def unzip_all(directory):
+    """
+    Recursively finds all .zip files in the directory and unzips them
+    in the same location as the zip file.
+    """
+    for root, dirs, files in os.walk(directory):
+        for filename in files:
+            if filename.lower().endswith('.zip'):
+                zip_path = os.path.join(root, filename)
+                # Unzip in the same directory as the zip file
+                print(f"Unzipping {zip_path}...")
+                try:
+                    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                        zip_ref.extractall(root)
+                    print(f"Done unzipping {zip_path}")
+                except zipfile.BadZipFile:
+                    print(f"Warning: {zip_path} is not a valid zip file, skipping...")
+                except Exception as e:
+                    print(f"Error unzipping {zip_path}: {e}")
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python unzip.py <directory>")
+    else:
+        unzip_all(sys.argv[1])

MODEL_COMBINATION_GUIDE.md

@@ -0,0 +1,157 @@
+# Model Combination Guide
+
+## Overview
+
+This guide explains how to combine predictions from three YOLO models to produce a unified COCO-format output with only the classes defined in `coco_class_mapping`.
+
+## The Three Models
+
+### 1. **best_emanuskript_segmentation.pt**
+- **Type**: Segmentation model
+- **Classes**: 21 classes including:
+  - Border, Table, Diagram, Music
+  - Main script black/coloured
+  - Variant script black/coloured
+  - Plain initial (coloured/highlighted/black)
+  - Historiated, Inhabited, Embellished
+  - Page Number, Quire Mark, Running header, Catchword, Gloss, Illustrations
+
+### 2. **best_catmus.pt**
+- **Type**: Segmentation model
+- **Classes**: 19 classes including:
+  - DefaultLine, InterlinearLine
+  - MainZone, MarginTextZone
+  - DropCapitalZone, GraphicZone, MusicZone
+  - NumberingZone, QuireMarksZone, RunningTitleZone
+  - StampZone, TitlePageZone
+
+### 3. **best_zone_detection.pt**
+- **Type**: Detection model
+- **Classes**: 11 zone classes:
+  - MainZone, MarginTextZone
+  - DropCapitalZone, GraphicZone, MusicZone
+  - NumberingZone, QuireMarksZone, RunningTitleZone
+  - StampZone, TitlePageZone, DigitizationArtefactZone
+
+## How It Works
+
+### Step 1: Run Model Predictions
+Each model is run independently on the input image:
+```python
+# Emanuskript model
+emanuskript_results = model.predict(image_path, classes=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,20])
+
+# Catmus model  
+catmus_results = model.predict(image_path, classes=[1,7])  # DefaultLine and InterlinearLine
+
+# Zone model
+zone_results = model.predict(image_path)  # All classes
+```
+
+Predictions are saved to JSON files in separate folders.
+
+### Step 2: Combine Predictions (ImageBatch Class)
+
+The `ImageBatch` class (`utils/image_batch_classes.py`) handles:
+
+1. **Loading Images**: Loads the image and gets dimensions
+2. **Loading Annotations**: Loads predictions from all 3 JSON files
+3. **Unifying Names**: Maps class names using `catmus_zones_mapping`:
+   - `DefaultLine` → `Main script black`
+   - `InterlinearLine` → `Gloss`
+   - `MainZone` → `Column`
+   - `DropCapitalZone` → `Plain initial- coloured`
+   - etc.
+
+4. **Filtering Annotations**: 
+   - Removes overlapping annotations based on spatial indexing
+   - Uses overlap thresholds (0.3-0.8 depending on class)
+   - Handles conflicts between different model predictions
+
+5. **COCO Format Conversion**: Converts to COCO JSON format
+
+### Step 3: Filter to coco_class_mapping
+
+Only annotations with classes in `coco_class_mapping` are kept (25 classes total).
+
+## Key Functions
+
+### `predict_annotations()` (in `utils/data.py`)
+- Runs a single model on an image
+- Saves predictions to JSON
+- Used by Celery tasks for async processing
+
+### `unify_predictions()` (in `utils/data.py`)
+- Combines predictions from all three models
+- Uses `ImageBatch` to process and filter
+- Returns COCO format JSON
+- Imports annotations into database
+
+### `ImageBatch` class (in `utils/image_batch_classes.py`)
+- Main class for combining predictions
+- Methods:
+  - `load_images()`: Load image files
+  - `load_annotations()`: Load predictions from JSON files
+  - `unify_names()`: Map class names to coco_class_mapping
+  - `filter_annotations()`: Remove overlapping annotations
+  - `return_coco_file()`: Generate COCO JSON
+
+## Usage Example
+
+```python
+from ultralytics import YOLO
+from utils.image_batch_classes import ImageBatch
+
+# 1. Run models (or use predict_annotations function)
+# ... save predictions to JSON files ...
+
+# 2. Combine predictions
+image_batch = ImageBatch(
+    image_folder="path/to/images",
+    catmus_labels_folder="path/to/catmus/predictions",
+    emanuskript_labels_folder="path/to/emanuskript/predictions",
+    zone_labels_folder="path/to/zone/predictions"
+)
+
+image_batch.load_images()
+image_batch.load_annotations()
+image_batch.unify_names()
+
+# 3. Get COCO format
+coco_json = image_batch.return_coco_file()
+```
+
+## Running the Test Script
+
+```bash
+python3 test_combined_models.py
+```
+
+This will:
+1. Run all three models on `bnf-naf-10039__page-001-of-004.jpg`
+2. Combine and filter predictions
+3. Save results to `combined_predictions.json`
+4. Print a summary of detected classes
+
+## Output Format
+
+The final output is a COCO-format JSON file with:
+- **images**: Image metadata (id, width, height, filename)
+- **categories**: List of category definitions (25 classes from coco_class_mapping)
+- **annotations**: List of annotations with:
+  - `id`: Annotation ID
+  - `image_id`: Associated image ID
+  - `category_id`: Class ID from coco_class_mapping
+  - `segmentation`: Polygon coordinates
+  - `bbox`: Bounding box [x, y, width, height]
+  - `area`: Polygon area
+
+## Class Mapping
+
+The `catmus_zones_mapping` in `image_batch_classes.py` maps:
+- Catmus/Zone model classes → coco_class_mapping classes
+- Example: `DefaultLine` → `Main script black`
+- Example: `MainZone` → `Column`
+
+Only classes that map to `coco_class_mapping` are included in the final output.
+

_app_.py

@@ -0,0 +1,1543 @@
+from typing import Tuple, Dict, List, Union
+import gradio as gr
+import supervision as sv
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+from ultralytics import YOLO, YOLOE
+import zipfile
+import os
+import tempfile
+import cv2
+import json
+from datetime import datetime
+import io
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend
+
+# Define custom models
+MODEL_FILES = {
+    "Line Detection": "best_line_detection_yoloe (1).pt",  # Use YOLOE for this
+    "Border Detection": "border_model_weights.pt",         # Still YOLO
+    "Zones Detection": "zones_model_weights.pt"            # Still YOLO
+}
+
+# Dictionary to store loaded models
+models: Dict[str, Union[YOLO, YOLOE]] = {}
+
+# Model class definitions - Expected/desired classes
+EXPECTED_MODEL_CLASSES = {
+    "Line Detection": [
+        "line"
+    ],
+    "Border Detection": [
+        "border",
+        "decorated_initial",
+        "historiated_initial", 
+        "illustration",
+        "page",
+        "simple_initial"
+    ],
+    "Zones Detection": [
+        "CustomZone-PageHeight",
+        "CustomZone-PageWidth",
+        "DamageZone",
+        "DigitizationArtefactZone",
+        "DropCapitalZone",
+        "GraphicZone",
+        "MainZone",
+        "MarginTextZone",
+        "MusicZone",
+        "NumberingZone",
+        "PageZone",
+        "QuireMarksZone",
+        "RunningTitleZone",
+        "StampZone",
+        "TitlePageZone"
+    ]
+}
+
+# Model class definitions - will be populated dynamically from actual models
+MODEL_CLASSES = {}
+
+# Global variables to store results for download
+current_results = []
+current_images = []
+
+# Load all custom models
+# Get the directory where this script is located
+script_dir = os.path.dirname(os.path.abspath(__file__))
+
+for name, model_file in MODEL_FILES.items():
+    model_path = os.path.join(script_dir, model_file)
+    if os.path.exists(model_path):
+        try:
+            if name == "Line Detection":
+                # Load YOLOE for line detection
+                models[name] = YOLOE(model_path)
+            else:
+                # Load YOLO for other tasks
+                models[name] = YOLO(model_path)
+            
+            # Read actual classes from the model
+            if models[name] is not None:
+                # Read classes from model
+                actual_classes = list(models[name].names.values())
+                
+                # Map "object" to "line" for Line Detection model in MODEL_CLASSES
+                if name == "Line Detection" and "object" in actual_classes:
+                    actual_classes = ["line" if c == "object" else c for c in actual_classes]
+                    print(f"   Mapped class 'object' to 'line' in Line Detection model for UI")
+                
+                MODEL_CLASSES[name] = actual_classes
+                
+                # Check for mismatch with expected classes
+                if name in EXPECTED_MODEL_CLASSES:
+                    expected = set(EXPECTED_MODEL_CLASSES[name])
+                    actual = set(actual_classes)
+                    if expected != actual:
+                        print(f"⚠️  WARNING: {name} model class mismatch!")
+                        print(f"   Expected: {sorted(expected)}")
+                        print(f"   Actual: {sorted(actual)}")
+                        print(f"   Missing in model: {sorted(expected - actual)}")
+                        print(f"   Extra in model: {sorted(actual - expected)}")
+                        print(f"   ⚠️  Using ACTUAL classes from model: {sorted(actual)}")
+            
+            print(f"✓ Loaded {name} model from {model_path}")
+            print(f"  Classes available: {MODEL_CLASSES.get(name, 'Unknown')}")
+        except Exception as e:
+            print(f"✗ Error loading {name} model: {e}")
+            models[name] = None
+            # Fallback to expected classes if model fails to load
+            MODEL_CLASSES[name] = EXPECTED_MODEL_CLASSES.get(name, [])
+    else:
+        print(f"✗ Warning: Model file {model_path} not found")
+        models[name] = None
+        # Fallback to expected classes if model file not found
+        MODEL_CLASSES[name] = EXPECTED_MODEL_CLASSES.get(name, [])
+
+
+# Create annotators
+LABEL_ANNOTATOR = sv.LabelAnnotator(text_color=sv.Color.BLACK)
+BOX_ANNOTATOR = sv.BoxAnnotator()
+MASK_ANNOTATOR = sv.MaskAnnotator()
+
+def detect_and_annotate_combined(
+    image: np.ndarray,
+    conf_threshold: float,
+    iou_threshold: float,
+    return_annotations: bool = False,
+    selected_classes: Dict[str, List[str]] = None
+) -> Union[np.ndarray, Tuple[np.ndarray, Dict]]:
+    """Run all three models and combine their outputs in a single annotated image"""
+    print(f"🔍 Starting detection on image shape: {image.shape}")
+    
+    # Colors for different models - more distinct colors
+    colors = {
+        "Line Detection": sv.Color.from_hex("#FF0000"),      # Bright Red
+        "Border Detection": sv.Color.from_hex("#00FF00"),   # Bright Green  
+        "Zones Detection": sv.Color.from_hex("#0080FF")     # Bright Blue
+    }
+    
+    # Model prefixes for clear labeling
+    model_prefixes = {
+        "Line Detection": "[LINE]",
+        "Border Detection": "[BORDER]", 
+        "Zones Detection": "[ZONE]"
+    }
+    
+    annotated_image = image.copy()
+    total_detections = 0
+    detections_data = {}
+    
+    # Run each model and annotate with different colors
+    for model_name, model in models.items():
+        if model is None:
+            print(f"⏭️  Skipping {model_name} (model not loaded)")
+            detections_data[model_name] = []
+            continue
+            
+        # Check if any classes are selected for this model BEFORE running inference
+        if selected_classes and model_name in selected_classes:
+            selected_class_names = selected_classes[model_name]
+            # If no classes selected for this model, skip it entirely (don't run inference)
+            if not selected_class_names:
+                print(f"⏭️  Skipping {model_name} (no classes selected)")
+                detections_data[model_name] = []
+                continue
+        elif selected_classes is not None:
+            # If selected_classes is provided but this model not in it, skip it
+            print(f"⏭️  Skipping {model_name} (model not in selected classes)")
+            detections_data[model_name] = []
+            continue
+        
+        print(f"🤖 Running {model_name} model...")
+        
+        # Perform inference (guard against per-model failures)
+        try:
+            results = model.predict(
+                image,
+                conf=conf_threshold,
+                iou=iou_threshold
+            )[0]
+        except Exception as e:
+            print(f"✗ {model_name} inference failed: {e}")
+            detections_data[model_name] = []
+            continue
+
+        model_detections = []
+        
+        if len(results.boxes) > 0:
+            # Convert results to supervision Detections
+            boxes = results.boxes.xyxy.cpu().numpy()
+            confidence = results.boxes.conf.cpu().numpy()
+            class_ids = results.boxes.cls.cpu().numpy().astype(int)
+            
+            # Filter by selected classes - only show selected classes
+            if selected_classes and model_name in selected_classes:
+                selected_class_names = selected_classes[model_name]
+                
+                # Get class names for this model
+                model_class_names = results.names
+                # Find class IDs that match selected class names
+                selected_class_ids = []
+                for class_id, class_name in model_class_names.items():
+                    # For Line Detection: also match "object" when user selects "line"
+                    if model_name == "Line Detection" and class_name == "object" and "line" in selected_class_names:
+                        selected_class_ids.append(class_id)
+                    elif class_name in selected_class_names:
+                        selected_class_ids.append(class_id)
+                
+                # Filter detections to only show selected classes
+                mask = np.isin(class_ids, selected_class_ids)
+                if not np.any(mask):
+                    print(f"   No detections match selected classes for {model_name}")
+                    detections_data[model_name] = []
+                    continue
+                
+                boxes = boxes[mask]
+                confidence = confidence[mask]
+                class_ids = class_ids[mask]
+                print(f"   Filtered to {len(boxes)} detections matching selected classes: {selected_class_names}")
+            
+            total_detections += len(boxes)
+            
+            # Store detection data for COCO format
+            for i, (box, conf, class_id) in enumerate(zip(boxes, confidence, class_ids)):
+                x1, y1, x2, y2 = box
+                width = x2 - x1
+                height = y2 - y1
+                
+                class_name = results.names[class_id]
+                # Map "object" to "line" for Line Detection model
+                if model_name == "Line Detection" and class_name == "object":
+                    class_name = "line"
+                
+                model_detections.append({
+                    "bbox": [float(x1), float(y1), float(width), float(height)],  # COCO format: [x, y, width, height]
+                    "class_name": class_name,
+                    "confidence": float(conf)
+                })
+            
+            
+            # Create Detections object for visualization
+            detections = sv.Detections(
+                xyxy=boxes,
+                confidence=confidence,
+                mask=results.masks.data.cpu().numpy() if results.masks is not None else None,
+                class_id=class_ids
+            )
+            
+            # Create labels with clear model prefixes and confidence scores
+            model_prefix = model_prefixes[model_name]
+            labels = []
+            for class_id, conf in zip(class_ids, confidence):
+                class_name = results.names[class_id]
+                # Map "object" to "line" for Line Detection model
+                if model_name == "Line Detection" and class_name == "object":
+                    class_name = "line"
+                labels.append(f"{model_prefix} {class_name} ({conf:.2f})")
+
+            # Create annotators with specific colors and improved styling
+            box_annotator = sv.BoxAnnotator(
+                color=colors[model_name],
+                thickness=3  # Thicker boxes for better visibility
+            )
+            label_annotator = sv.LabelAnnotator(
+                text_color=sv.Color.WHITE,
+                color=colors[model_name],
+                text_thickness=2,
+                text_scale=0.6,
+                text_padding=8
+            )
+            
+        # Replace the "annotate image" block inside detect_and_annotate_combined with this
+
+            # Annotate image depending on model type
+            if model_name == "Line Detection" and results.masks is not None:
+
+                original_h, original_w = annotated_image.shape[:2]
+
+                if detections.mask is not None:
+                    all_resized_masks = []
+                    for i, mask in enumerate(detections.mask):
+                        # ensure binary mask
+                        mask_np = (mask > 0).astype(np.uint8)
+                        resized_mask = cv2.resize(
+                            mask_np,
+                            (original_w, original_h),
+                            interpolation=cv2.INTER_NEAREST
+                        )
+                        resized_mask = resized_mask.astype(bool)  # <- important
+                        all_resized_masks.append(resized_mask)
+
+                    all_resized_masks = np.stack(all_resized_masks, axis=0)  # (N, H, W)
+                    detections.mask = all_resized_masks  # overwrite with clean boolean masks
+                    print("Resized masks:", detections.mask.shape, detections.mask.dtype)
+                else:
+                    detections.mask = None
+
+
+                # Use MaskAnnotator for line detection
+                mask_annotator = sv.MaskAnnotator(
+                    color=colors[model_name],
+                    opacity=0.6
+                )
+                annotated_image = mask_annotator.annotate(scene=annotated_image, detections=detections)
+                
+                # Add labels on top of masks
+                annotated_image = label_annotator.annotate(
+                    scene=annotated_image,
+                    detections=detections,
+                    labels=labels
+                )
+            else:
+                # Use BoxAnnotator for Border and Zones
+                annotated_image = box_annotator.annotate(scene=annotated_image, detections=detections)
+                annotated_image = label_annotator.annotate(scene=annotated_image, detections=detections, labels=labels)
+
+        else:
+            print(f"   No detections found for {model_name}")
+        
+        detections_data[model_name] = model_detections
+    
+    print(f"🎯 Detection completed. Total detections: {total_detections}")
+    
+    if return_annotations:
+        return annotated_image, detections_data
+    else:
+        return annotated_image
+
+def process_zip_file(zip_file_path: str, conf_threshold: float, iou_threshold: float, selected_classes: Dict[str, List[str]] = None) -> Tuple[List[Tuple[str, np.ndarray]], List[Tuple[str, Dict]], Dict]:
+    """Process all images in a zip file and return annotated images, detection data, and image info"""
+    print(f"📁 Opening ZIP file: {zip_file_path}")
+    results = []
+    annotations_data = []
+    image_info = {}
+    
+    try:
+        with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
+            print(f"📋 ZIP file contents: {zip_ref.namelist()}")
+            
+            # Create temporary directory to extract files
+            with tempfile.TemporaryDirectory() as temp_dir:
+                print(f"📂 Extracting to temporary directory: {temp_dir}")
+                zip_ref.extractall(temp_dir)
+                
+                # List all files in temp directory
+                all_files = os.listdir(temp_dir)
+                print(f"📄 Files extracted: {all_files}")
+                
+                # Process each image file (recursively search through folders)
+                image_count = 0
+                
+                # Walk through all directories and subdirectories
+                for root, dirs, files in os.walk(temp_dir):
+                    print(f"📂 Searching in directory: {root}")
+                    
+                    for filename in files:
+                        # Skip macOS hidden files
+                        if filename.startswith('._') or filename.startswith('.DS_Store'):
+                            print(f"⏭️  Skipping system file: {filename}")
+                            continue
+                            
+                        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff')):
+                            image_count += 1
+                            image_path = os.path.join(root, filename)
+                            print(f"🖼️  Processing image {image_count}: {filename} (from {os.path.relpath(root, temp_dir)})")
+                            
+                            # Load image
+                            image = cv2.imread(image_path)
+                            if image is not None:
+                                print(f"✅ Image loaded successfully: {image.shape}")
+                                image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+                                
+                                # Store image info
+                                height, width = image.shape[:2]
+                                image_info[filename] = (height, width)
+                                
+                                # Process with all models and get annotation data
+                                print(f"🔍 Running detection models on {filename}...")
+                                annotated_image, detections_data = detect_and_annotate_combined(
+                                    image, conf_threshold, iou_threshold, return_annotations=True, selected_classes=selected_classes
+                                )
+                                print(f"✅ Detection completed for {filename}")
+                                
+                                results.append((filename, annotated_image))
+                                annotations_data.append((filename, detections_data))
+                            else:
+                                print(f"❌ Failed to load image: {filename}")
+                        else:
+                            print(f"⏭️  Skipping non-image file: {filename}")
+                
+                print(f"📊 Total images processed: {len(results)} out of {image_count} image files found")
+                print(f"📁 Searched through all subdirectories recursively")
+        
+        print(f"🎉 ZIP processing completed successfully! Processed {len(results)} images")
+        return results, annotations_data, image_info
+        
+    except Exception as e:
+        print(f"💥 ERROR in process_zip_file: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return [], [], {}
+
+def create_coco_annotations(results_data: List, image_info: Dict) -> Dict:
+    """Convert detection results to COCO JSON format"""
+    coco_data = {
+        "info": {
+            "description": "Medieval Manuscript Detection Results",
+            "version": "1.0",
+            "year": datetime.now().year,
+            "contributor": "Medieval YOLO Models",
+            "date_created": datetime.now().isoformat()
+        },
+        "licenses": [
+            {
+                "id": 1,
+                "name": "Custom License",
+                "url": ""
+            }
+        ],
+        "images": [],
+        "annotations": [],
+        "categories": []
+    }
+    
+    # Create categories from all models
+    category_id = 1
+    category_map = {}
+    
+    # Add categories for each model type
+    for model_name in ["Line Detection", "Border Detection", "Zones Detection"]:
+        if model_name in models and models[model_name] is not None:
+            model = models[model_name]
+            for class_id, class_name in model.names.items():
+                full_name = f"{model_name}_{class_name}"
+                if full_name not in category_map:
+                    category_map[full_name] = category_id
+                    coco_data["categories"].append({
+                        "id": category_id,
+                        "name": full_name,
+                        "supercategory": model_name
+                    })
+                    category_id += 1
+    
+    annotation_id = 1
+    
+    for image_idx, (filename, detections_by_model) in enumerate(results_data):
+        # Add image info
+        image_id = image_idx + 1
+        img_height, img_width = image_info.get(filename, (0, 0))
+        
+        coco_data["images"].append({
+            "id": image_id,
+            "file_name": filename,
+            "width": img_width,
+            "height": img_height,
+            "license": 1
+        })
+        
+        # Add annotations for each model
+        for model_name, detections in detections_by_model.items():
+            if detections:
+                for detection in detections:
+                    bbox = detection["bbox"]  # [x, y, width, height]
+                    class_name = detection["class_name"]
+                    confidence = detection["confidence"]
+                    
+                    full_category_name = f"{model_name}_{class_name}"
+                    category_id = category_map.get(full_category_name, 1)
+                    
+                    coco_data["annotations"].append({
+                        "id": annotation_id,
+                        "image_id": image_id,
+                        "category_id": category_id,
+                        "bbox": bbox,
+                        "area": bbox[2] * bbox[3],
+                        "iscrowd": 0,
+                        "score": confidence
+                    })
+                    annotation_id += 1
+    
+    return coco_data
+
+def create_download_zip(images: List[Tuple[str, np.ndarray]], annotations: Dict) -> str:
+    """Create a ZIP file with images and annotations"""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    zip_filename = f"medieval_detection_results_{timestamp}.zip"
+    zip_path = os.path.join(tempfile.gettempdir(), zip_filename)
+    
+    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        # Add images
+        for filename, image_array in images:
+            # Convert numpy array to PIL Image and save as bytes
+            pil_image = Image.fromarray(image_array.astype('uint8'))
+            img_bytes = io.BytesIO()
+            
+            # Determine format from filename
+            if filename.lower().endswith('.png'):
+                pil_image.save(img_bytes, format='PNG')
+            else:
+                pil_image.save(img_bytes, format='JPEG')
+            
+            # Add to ZIP
+            zipf.writestr(f"images/{filename}", img_bytes.getvalue())
+        
+        # Add annotations
+        annotations_json = json.dumps(annotations, indent=2)
+        zipf.writestr("annotations.json", annotations_json)
+        
+        # Add README
+        readme_content = f"""Medieval Manuscript Detection Results
+=============================================
+
+Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+Contents:
+- images/: Annotated images with detection results
+- annotations.json: COCO format annotations
+
+Models and Color Coding:
+- Line Detection (Red boxes with [LINE] prefix)
+- Border Detection (Green boxes with [BORDER] prefix) 
+- Zones Detection (Blue boxes with [ZONE] prefix)
+
+Label format: [MODEL] class_name (confidence_score)
+Annotation format: COCO JSON
+For more info: https://cocodataset.org/#format-data
+"""
+        zipf.writestr("README.txt", readme_content)
+    
+    return zip_path
+
+def calculate_statistics(detections_data: Dict, selected_classes: Dict[str, List[str]] = None) -> Dict[str, int]:
+    """Calculate statistics (count per class) from detections_data"""
+    stats = {}
+    
+    for model_name, detections in detections_data.items():
+        if not detections:
+            continue
+            
+        # Filter by selected classes if provided
+        for detection in detections:
+            class_name = detection["class_name"]
+            
+            # Only count if class is in selected classes (if selected_classes is provided)
+            if selected_classes:
+                if model_name not in selected_classes:
+                    continue
+                if class_name not in selected_classes[model_name]:
+                    continue
+            
+            # Create full class identifier (model_name + class_name)
+            full_class_name = f"{model_name} - {class_name}"
+            
+            if full_class_name not in stats:
+                stats[full_class_name] = 0
+            stats[full_class_name] += 1
+    
+    return stats
+
+def create_statistics_table(stats: Dict[str, int], image_name: str = None) -> pd.DataFrame:
+    """Create a pandas DataFrame table from statistics"""
+    if not stats:
+        return pd.DataFrame(columns=["Class", "Count"])
+    
+    data = []
+    for class_name, count in sorted(stats.items()):
+        data.append({"Class": class_name, "Count": count})
+    
+    df = pd.DataFrame(data)
+    if image_name:
+        df.insert(0, "Image", image_name)
+    
+    return df
+
+def create_statistics_graph(stats: Dict[str, int], image_name: str = None) -> str:
+    """Create a bar chart from statistics and return as image path"""
+    if not stats:
+        # Return empty graph
+        fig, ax = plt.subplots(figsize=(10, 6))
+        ax.text(0.5, 0.5, "No detections found", ha='center', va='center', fontsize=14)
+        ax.set_xticks([])
+        ax.set_yticks([])
+    else:
+        classes = sorted(stats.keys())
+        counts = [stats[c] for c in classes]
+        
+        fig, ax = plt.subplots(figsize=(12, 6))
+        bars = ax.bar(range(len(classes)), counts, color='steelblue')
+        ax.set_xlabel('Class', fontsize=12)
+        ax.set_ylabel('Count', fontsize=12)
+        ax.set_title(f'Detection Statistics{(" - " + image_name) if image_name else ""}', fontsize=14, fontweight='bold')
+        ax.set_xticks(range(len(classes)))
+        ax.set_xticklabels(classes, rotation=45, ha='right')
+        
+        # Add count labels on bars
+        for bar, count in zip(bars, counts):
+            height = bar.get_height()
+            ax.text(bar.get_x() + bar.get_width()/2., height,
+                   f'{count}',
+                   ha='center', va='bottom', fontsize=10)
+        
+        plt.tight_layout()
+    
+    # Save to temporary file
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    graph_path = os.path.join(tempfile.gettempdir(), f"statistics_graph_{timestamp}.png")
+    fig.savefig(graph_path, dpi=150, bbox_inches='tight')
+    plt.close(fig)
+    
+    return graph_path
+
+def create_statistics_csv(stats: Dict[str, int], image_name: str = None) -> str:
+    """Create CSV file from statistics"""
+    df = create_statistics_table(stats, image_name)
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    csv_path = os.path.join(tempfile.gettempdir(), f"statistics_{timestamp}.csv")
+    df.to_csv(csv_path, index=False)
+    
+    return csv_path
+
+def create_statistics_json(stats: Dict[str, int], image_name: str = None) -> str:
+    """Create JSON file from statistics"""
+    data = {
+        "image": image_name,
+        "timestamp": datetime.now().isoformat(),
+        "statistics": stats
+    }
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    json_path = os.path.join(tempfile.gettempdir(), f"statistics_{timestamp}.json")
+    
+    with open(json_path, 'w') as f:
+        json.dump(data, f, indent=2)
+    
+    return json_path
+
+def calculate_batch_statistics(results_data: List[Tuple[str, Dict]], selected_classes: Dict[str, List[str]] = None) -> pd.DataFrame:
+    """Calculate statistics for all images in batch processing - per image"""
+    all_stats = []
+    
+    for filename, detections_by_model in results_data:
+        stats = calculate_statistics(detections_by_model, selected_classes)
+        df = create_statistics_table(stats, filename)
+        if not df.empty:
+            all_stats.append(df)
+    
+    if all_stats:
+        combined_df = pd.concat(all_stats, ignore_index=True)
+        return combined_df
+    else:
+        return pd.DataFrame(columns=["Image", "Class", "Count"])
+
+def calculate_batch_statistics_summary(results_data: List[Tuple[str, Dict]], selected_classes: Dict[str, List[str]] = None) -> pd.DataFrame:
+    """Calculate overall aggregated statistics for all images in batch"""
+    # Aggregate statistics across all images
+    all_stats = {}
+    
+    for filename, detections_by_model in results_data:
+        stats = calculate_statistics(detections_by_model, selected_classes)
+        for class_name, count in stats.items():
+            if class_name not in all_stats:
+                all_stats[class_name] = 0
+            all_stats[class_name] += count
+    
+    # Create summary table
+    if not all_stats:
+        return pd.DataFrame(columns=["Class", "Total Count"])
+    
+    data = []
+    for class_name, count in sorted(all_stats.items()):
+        data.append({"Class": class_name, "Total Count": count})
+    
+    return pd.DataFrame(data)
+
+def create_batch_statistics_graph(results_data: List[Tuple[str, Dict]], selected_classes: Dict[str, List[str]] = None) -> str:
+    """Create a graph showing statistics across all images in batch"""
+    # Aggregate statistics across all images
+    all_stats = {}
+    
+    for filename, detections_by_model in results_data:
+        stats = calculate_statistics(detections_by_model, selected_classes)
+        for class_name, count in stats.items():
+            if class_name not in all_stats:
+                all_stats[class_name] = 0
+            all_stats[class_name] += count
+    
+    return create_statistics_graph(all_stats, "Batch Processing")
+
+def create_batch_statistics_csv(results_data: List[Tuple[str, Dict]], selected_classes: Dict[str, List[str]] = None) -> str:
+    """Create CSV file from batch statistics - includes both per-image and summary"""
+    # Get per-image statistics
+    per_image_df = calculate_batch_statistics(results_data, selected_classes)
+    # Get summary statistics
+    summary_df = calculate_batch_statistics_summary(results_data, selected_classes)
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    csv_path = os.path.join(tempfile.gettempdir(), f"batch_statistics_{timestamp}.csv")
+    
+    # Write both to CSV with separator
+    with open(csv_path, 'w') as f:
+        # Write per-image statistics
+        f.write("=== PER IMAGE STATISTICS ===\n")
+        per_image_df.to_csv(f, index=False)
+        f.write("\n\n=== OVERALL SUMMARY STATISTICS ===\n")
+        summary_df.to_csv(f, index=False)
+    
+    return csv_path
+
+def create_batch_statistics_json(results_data: List[Tuple[str, Dict]], selected_classes: Dict[str, List[str]] = None) -> str:
+    """Create JSON file from batch statistics - includes both per-image and summary"""
+    # Calculate summary statistics
+    summary_stats = {}
+    for filename, detections_by_model in results_data:
+        stats = calculate_statistics(detections_by_model, selected_classes)
+        for class_name, count in stats.items():
+            if class_name not in summary_stats:
+                summary_stats[class_name] = 0
+            summary_stats[class_name] += count
+    
+    data = {
+        "batch_processing": True,
+        "timestamp": datetime.now().isoformat(),
+        "total_images": len(results_data),
+        "per_image_statistics": [],
+        "overall_summary": summary_stats
+    }
+    
+    for filename, detections_by_model in results_data:
+        stats = calculate_statistics(detections_by_model, selected_classes)
+        data["per_image_statistics"].append({
+            "filename": filename,
+            "statistics": stats
+        })
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    json_path = os.path.join(tempfile.gettempdir(), f"batch_statistics_{timestamp}.json")
+    
+    with open(json_path, 'w') as f:
+        json.dump(data, f, indent=2)
+    
+    return json_path
+
+# Create Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Medieval Manuscript Detection with Custom YOLO Models")
+    gr.Markdown("""
+    **Models and Color Coding:**
+    - 🔵**Line Detection** - Red boxes with [LINE] prefix
+    - 🟢 **Border Detection** - Green boxes with [BORDER] prefix  
+    - 🟠 **Zones Detection** - Blue boxes with [ZONE] prefix
+    
+    Each detection shows: **[MODEL] class_name (confidence_score)**
+    """)
+    
+    with gr.Tabs():
+        # Single Image Tab
+        with gr.TabItem("Single Image"):
+            with gr.Row():
+                with gr.Column():
+                    input_image = gr.Image(
+                        label="Input Image",
+                        type='numpy'
+                    )
+                    with gr.Accordion("Detection Settings", open=True):
+                        with gr.Row():
+                            conf_threshold = gr.Slider(
+                                label="Confidence Threshold",
+                                minimum=0.0,
+                                maximum=1.0,
+                                step=0.05,
+                                value=0.25,
+                            )
+                            iou_threshold = gr.Slider(
+                                label="IoU Threshold",
+                                minimum=0.0,
+                                maximum=1.0,
+                                step=0.05,
+                                value=0.45,
+                                info="Decrease for stricter detection, increase for more overlapping boxes"
+                            )
+                    
+                    with gr.Accordion("Class Selection", open=False):
+                        gr.Markdown("**Select which classes to detect for each model:**")
+                        with gr.Row():
+                            with gr.Column():
+                                line_classes = gr.CheckboxGroup(
+                                    label="Line Detection Classes",
+                                    choices=MODEL_CLASSES["Line Detection"],
+                                    value=MODEL_CLASSES["Line Detection"],  # All selected by default
+                                    info="Select at least one class for detection"
+                                )
+                                with gr.Row():
+                                    line_select_all = gr.Button("Select All", size="sm")
+                                    line_unselect_all = gr.Button("Unselect All", size="sm")
+                            with gr.Column():
+                                border_classes = gr.CheckboxGroup(
+                                    label="Border Detection Classes", 
+                                    choices=MODEL_CLASSES["Border Detection"],
+                                    value=MODEL_CLASSES["Border Detection"],  # All selected by default
+                                    info="Select at least one class for detection"
+                                )
+                                with gr.Row():
+                                    border_select_all = gr.Button("Select All", size="sm")
+                                    border_unselect_all = gr.Button("Unselect All", size="sm")
+                        with gr.Row():
+                            with gr.Column():
+                                zones_classes = gr.CheckboxGroup(
+                                    label="Zones Detection Classes",
+                                    choices=MODEL_CLASSES["Zones Detection"],
+                                    value=MODEL_CLASSES["Zones Detection"],  # All selected by default
+                                    info="Select at least one class for detection"
+                                )
+                                with gr.Row():
+                                    zones_select_all = gr.Button("Select All", size="sm")
+                                    zones_unselect_all = gr.Button("Unselect All", size="sm")
+                    with gr.Row():
+                        clear_btn = gr.Button("Clear")
+                        detect_btn = gr.Button("Detect with All Models", variant="primary")
+                        
+                with gr.Column():
+                    output_image = gr.Image(
+                        label="Combined Detection Result",
+                        type='numpy'
+                    )
+                    
+                    # Single image download buttons
+                    with gr.Row():
+                        single_download_json_btn = gr.Button(
+                            "📄 Download Annotations (JSON)",
+                            variant="secondary",
+                            size="sm"
+                        )
+                        single_download_image_btn = gr.Button(
+                            "🖼️ Download Image",
+                            variant="secondary",
+                            size="sm"
+                        )
+                    
+                    # Single image file outputs
+                    single_json_output = gr.File(
+                        label="📄 JSON Download",
+                        visible=True,
+                        height=50
+                    )
+                    single_image_output = gr.File(
+                        label="🖼️ Image Download",
+                        visible=True,
+                        height=50
+                    )
+                    
+                    # Statistics section for single image
+                    with gr.Accordion("📊 Statistics", open=False):
+                        with gr.Tabs():
+                            with gr.TabItem("Table"):
+                                single_stats_table = gr.Dataframe(
+                                    label="Detection Statistics",
+                                    headers=["Class", "Count"],
+                                    wrap=True
+                                )
+                            with gr.TabItem("Graph"):
+                                single_stats_graph = gr.Image(
+                                    label="Detection Statistics Graph",
+                                    type='filepath'
+                                )
+                        
+                        # Statistics download buttons
+                        with gr.Row():
+                            single_download_stats_csv_btn = gr.Button(
+                                "📊 Download Statistics (CSV)",
+                                variant="secondary",
+                                size="sm"
+                            )
+                            single_download_stats_json_btn = gr.Button(
+                                "📊 Download Statistics (JSON)",
+                                variant="secondary",
+                                size="sm"
+                            )
+                        
+                        single_stats_csv_output = gr.File(
+                            label="📊 Statistics CSV Download",
+                            visible=False,
+                            height=50
+                        )
+                        single_stats_json_output = gr.File(
+                            label="📊 Statistics JSON Download",
+                            visible=False,
+                            height=50
+                        )
+        
+        # Batch Processing Tab
+        with gr.TabItem("Batch Processing (ZIP)"):
+            with gr.Row():
+                with gr.Column():
+                    zip_file = gr.File(
+                        label="Upload ZIP file with images",
+                        file_types=[".zip"]
+                    )
+                    with gr.Accordion("Detection Settings", open=True):
+                        with gr.Row():
+                            batch_conf_threshold = gr.Slider(
+                                label="Confidence Threshold",
+                                minimum=0.0,
+                                maximum=1.0,
+                                step=0.05,
+                                value=0.25,
+                            )
+                            batch_iou_threshold = gr.Slider(
+                                label="IoU Threshold",
+                                minimum=0.0,
+                                maximum=1.0,
+                                step=0.05,
+                                value=0.45,
+                            )
+                    
+                    with gr.Accordion("Class Selection", open=False):
+                        gr.Markdown("**Select which classes to detect for each model:**")
+                        with gr.Row():
+                            with gr.Column():
+                                batch_line_classes = gr.CheckboxGroup(
+                                    label="Line Detection Classes",
+                                    choices=MODEL_CLASSES["Line Detection"],
+                                    value=MODEL_CLASSES["Line Detection"],  # All selected by default
+                                    info="Select at least one class for detection"
+                                )
+                                with gr.Row():
+                                    batch_line_select_all = gr.Button("Select All", size="sm")
+                                    batch_line_unselect_all = gr.Button("Unselect All", size="sm")
+                            with gr.Column():
+                                batch_border_classes = gr.CheckboxGroup(
+                                    label="Border Detection Classes", 
+                                    choices=MODEL_CLASSES["Border Detection"],
+                                    value=MODEL_CLASSES["Border Detection"],  # All selected by default
+                                    info="Select at least one class for detection"
+                                )
+                                with gr.Row():
+                                    batch_border_select_all = gr.Button("Select All", size="sm")
+                                    batch_border_unselect_all = gr.Button("Unselect All", size="sm")
+                        with gr.Row():
+                            with gr.Column():
+                                batch_zones_classes = gr.CheckboxGroup(
+                                    label="Zones Detection Classes",
+                                    choices=MODEL_CLASSES["Zones Detection"],
+                                    value=MODEL_CLASSES["Zones Detection"],  # All selected by default
+                                    info="Select at least one class for detection"
+                                )
+                                with gr.Row():
+                                    batch_zones_select_all = gr.Button("Select All", size="sm")
+                                    batch_zones_unselect_all = gr.Button("Unselect All", size="sm")
+                    
+                    # Add status message box
+                    batch_status = gr.Textbox(
+                        label="Processing Status",
+                        value="Ready to process ZIP file...",
+                        interactive=False,
+                        max_lines=3
+                    )
+                    
+                    with gr.Row():
+                        clear_batch_btn = gr.Button("Clear")
+                        process_batch_btn = gr.Button("Process ZIP", variant="primary")
+                        
+                with gr.Column():
+                    batch_gallery = gr.Gallery(
+                        label="Batch Processing Results",
+                        show_label=True,
+                        elem_id="gallery",
+                        columns=2,
+                        rows=2,
+                        height="auto",
+                        type="numpy"  # Explicitly handle numpy arrays
+                    )
+                    
+                    # Download buttons
+                    with gr.Row():
+                        download_json_btn = gr.Button(
+                            "📄 Download COCO Annotations (JSON)",
+                            variant="secondary"
+                        )
+                        download_zip_btn = gr.Button(
+                            "📦 Download Results (ZIP)",
+                            variant="secondary"
+                        )
+                    
+                    # File outputs for downloads
+                    json_file_output = gr.File(
+                        label="📄 JSON Download",
+                        visible=True,
+                        height=50
+                    )
+                    zip_file_output = gr.File(
+                        label="📦 ZIP Download",
+                        visible=True,
+                        height=50
+                    )
+                    
+                    # Statistics section for batch processing
+                    with gr.Accordion("📊 Statistics", open=False):
+                        with gr.Tabs():
+                            with gr.TabItem("Per Image"):
+                                batch_stats_table = gr.Dataframe(
+                                    label="Detection Statistics Per Image",
+                                    wrap=True
+                                )
+                            with gr.TabItem("Overall Summary"):
+                                batch_stats_summary_table = gr.Dataframe(
+                                    label="Overall Statistics Summary (All Images Combined)",
+                                    wrap=True
+                                )
+                            with gr.TabItem("Graph"):
+                                batch_stats_graph = gr.Image(
+                                    label="Detection Statistics Graph (Aggregated)",
+                                    type='filepath'
+                                )
+                        
+                        # Statistics download buttons
+                        with gr.Row():
+                            batch_download_stats_csv_btn = gr.Button(
+                                "📊 Download Statistics (CSV)",
+                                variant="secondary",
+                                size="sm"
+                            )
+                            batch_download_stats_json_btn = gr.Button(
+                                "📊 Download Statistics (JSON)",
+                                variant="secondary",
+                                size="sm"
+                            )
+                        
+                        batch_stats_csv_output = gr.File(
+                            label="📊 Statistics CSV Download",
+                            visible=False,
+                            height=50
+                        )
+                        batch_stats_json_output = gr.File(
+                            label="📊 Statistics JSON Download",
+                            visible=False,
+                            height=50
+                        )
+
+    # Global variables for single image results
+    single_image_result = None
+    single_image_annotations = None
+    single_image_filename = None
+    single_image_selected_classes = None
+    
+    def process_single_image(
+        image: np.ndarray,
+        conf_threshold: float,
+        iou_threshold: float,
+        line_classes: List[str],
+        border_classes: List[str],
+        zones_classes: List[str]
+    ) -> Tuple[np.ndarray, np.ndarray, pd.DataFrame, str]:
+        global single_image_result, single_image_annotations, single_image_filename, single_image_selected_classes
+        
+        if image is None:
+            single_image_result = None
+            single_image_annotations = None
+            single_image_filename = None
+            single_image_selected_classes = None
+            return None, None, pd.DataFrame(columns=["Class", "Count"]), None
+            
+        # Validate that at least one class is selected
+        all_selected = (line_classes or []) + (border_classes or []) + (zones_classes or [])
+        if not all_selected:
+            raise gr.Error("⚠️ Please select at least one class for detection!")
+        
+        # Prepare selected classes dictionary
+        selected_classes = {
+            "Line Detection": line_classes or [],
+            "Border Detection": border_classes or [],
+            "Zones Detection": zones_classes or []
+        }
+        
+        # Process with annotations
+        try:
+            annotated_image, detections_data = detect_and_annotate_combined(
+                image, conf_threshold, iou_threshold, return_annotations=True, selected_classes=selected_classes
+            )
+        except Exception as e:
+            # Surface a nice error to the UI without crashing the app
+            raise gr.Error(f"Detection failed: {str(e)}")
+        
+        # Calculate statistics
+        stats = calculate_statistics(detections_data, selected_classes)
+        stats_table = create_statistics_table(stats, single_image_filename)
+        stats_graph_path = create_statistics_graph(stats, single_image_filename)
+        
+        # Store results globally for download
+        single_image_result = annotated_image
+        single_image_annotations = detections_data
+        single_image_selected_classes = selected_classes
+        single_image_filename = f"detection_result_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg"
+        
+        return image, annotated_image, stats_table, stats_graph_path
+
+    # Global variables for batch results
+    current_batch_results = []
+    current_batch_selected_classes = None
+    
+    def process_batch_images_with_status(
+        zip_file,
+        conf_threshold: float,
+        iou_threshold: float,
+        line_classes: List[str],
+        border_classes: List[str],
+        zones_classes: List[str]
+    ):
+        global current_batch_results, current_batch_selected_classes
+        
+        print("🚀 ========== BATCH PROCESSING STARTED ==========")
+        
+        if zip_file is None:
+            print("❌ No ZIP file provided")
+            return [], "Please upload a ZIP file first.", pd.DataFrame(columns=["Image", "Class", "Count"]), pd.DataFrame(columns=["Class", "Total Count"]), None
+        
+        print(f"📁 ZIP file received: {zip_file.name}")
+        print(f"⚙️  Settings: conf_threshold={conf_threshold}, iou_threshold={iou_threshold}")
+        
+        try:
+            # Validate that at least one class is selected
+            all_selected = (line_classes or []) + (border_classes or []) + (zones_classes or [])
+            if not all_selected:
+                raise gr.Error("⚠️ Please select at least one class for detection!")
+            
+            # Prepare selected classes dictionary
+            selected_classes = {
+                "Line Detection": line_classes or [],
+                "Border Detection": border_classes or [],
+                "Zones Detection": zones_classes or []
+            }
+            current_batch_selected_classes = selected_classes
+            
+            # Process zip file
+            print("🔄 Starting ZIP file processing...")
+            results, annotations_data, image_info = process_zip_file(zip_file.name, conf_threshold, iou_threshold, selected_classes)
+            
+            # Store batch results globally
+            current_batch_results = results
+            
+            if not results:
+                error_msg = "No valid images found in ZIP file."
+                print(f"❌ {error_msg}")
+                return [], error_msg
+            
+            # Store data globally for download
+            global current_results, current_images
+            current_images = results
+            current_results = annotations_data
+            
+            print(f"📊 ZIP processing returned {len(results)} results")
+            
+            # Convert results to format expected by Gallery
+            print("🔄 Converting results for Gradio Gallery...")
+            gallery_images = []
+            
+            for i, (filename, annotated_image) in enumerate(results):
+                print(f"🖼️  Converting image {i+1}/{len(results)}: {filename}")
+                print(f"   Image shape: {annotated_image.shape}, dtype: {annotated_image.dtype}")
+                
+                # Ensure the image is in the right format and range
+                if annotated_image.dtype != 'uint8':
+                    print(f"   Converting dtype from {annotated_image.dtype} to uint8")
+                    # Normalize if needed
+                    if annotated_image.max() <= 1.0:
+                        annotated_image = (annotated_image * 255).astype('uint8')
+                        print(f"   Normalized from [0,1] to [0,255]")
+                    else:
+                        annotated_image = annotated_image.astype('uint8')
+                        print(f"   Cast to uint8")
+                
+                print(f"   Final image shape: {annotated_image.shape}, dtype: {annotated_image.dtype}")
+                
+                # For Gradio gallery, we can pass numpy arrays directly
+                # Format: (image_data, caption)
+                gallery_images.append((annotated_image, filename))
+                print(f"   ✅ Added {filename} to gallery")
+            
+            # Calculate statistics (use annotations_data, not results)
+            stats_table = calculate_batch_statistics(annotations_data, selected_classes)
+            stats_summary_table = calculate_batch_statistics_summary(annotations_data, selected_classes)
+            stats_graph_path = create_batch_statistics_graph(annotations_data, selected_classes)
+            
+            success_msg = f"✅ Successfully processed {len(gallery_images)} images!"
+            print(f"🎉 {success_msg}")
+            print(f"📋 Gallery contains {len(gallery_images)} items")
+            print("🏁 ========== BATCH PROCESSING COMPLETED ==========\n")
+            
+            return gallery_images, success_msg, stats_table, stats_summary_table, stats_graph_path
+            
+        except Exception as e:
+            error_msg = f"❌ Error: {str(e)}"
+            print(f"💥 EXCEPTION in process_batch_images_with_status: {error_msg}")
+            import traceback
+            traceback.print_exc()
+            print("💀 ========== BATCH PROCESSING FAILED ==========\n")
+            return [], error_msg, pd.DataFrame(columns=["Image", "Class", "Count"]), pd.DataFrame(columns=["Class", "Total Count"]), None
+
+    def clear_single():
+        global single_image_result, single_image_annotations, single_image_filename, single_image_selected_classes
+        single_image_result = None
+        single_image_annotations = None
+        single_image_filename = None
+        single_image_selected_classes = None
+        return None, None, pd.DataFrame(columns=["Class", "Count"]), None
+    
+    def clear_batch():
+        global current_results, current_images
+        current_results = []
+        current_images = []
+        return None, [], "Ready to process ZIP file..."
+    
+    def download_annotations():
+        """Create and return COCO JSON annotations file"""
+        global current_results, current_images
+        
+        if not current_results:
+            print("❌ No annotation data available for download")
+            return None
+        
+        try:
+            # Create image info dictionary
+            image_info = {}
+            for filename, image_array in current_images:
+                height, width = image_array.shape[:2]
+                image_info[filename] = (height, width)
+            
+            # Create COCO annotations
+            coco_data = create_coco_annotations(current_results, image_info)
+            
+            # Save to temporary file with proper name
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            json_filename = f"medieval_annotations_{timestamp}.json"
+            json_path = os.path.join(tempfile.gettempdir(), json_filename)
+            
+            with open(json_path, 'w') as f:
+                json.dump(coco_data, f, indent=2)
+            
+            print(f"💾 Created annotations file: {json_path}")
+            print(f"📁 File size: {os.path.getsize(json_path)} bytes")
+            
+            # Verify file exists and is readable
+            if os.path.exists(json_path) and os.path.getsize(json_path) > 0:
+                return json_path
+            else:
+                print(f"❌ File verification failed: {json_path}")
+                return None
+            
+        except Exception as e:
+            print(f"❌ Error creating annotations: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+    
+    def download_results_zip():
+        """Create and return ZIP file with images and annotations"""
+        global current_results, current_images
+        
+        if not current_results or not current_images:
+            print("❌ No results data available for ZIP download")
+            return None
+        
+        try:
+            # Create image info dictionary
+            image_info = {}
+            for filename, image_array in current_images:
+                height, width = image_array.shape[:2]
+                image_info[filename] = (height, width)
+            
+            # Create COCO annotations
+            coco_data = create_coco_annotations(current_results, image_info)
+            
+            # Create ZIP file
+            zip_path = create_download_zip(current_images, coco_data)
+            
+            print(f"💾 Created results ZIP: {zip_path}")
+            print(f"📁 ZIP file size: {os.path.getsize(zip_path)} bytes")
+            
+            # Verify file exists and is readable
+            if os.path.exists(zip_path) and os.path.getsize(zip_path) > 0:
+                return zip_path
+            else:
+                print(f"❌ ZIP file verification failed: {zip_path}")
+                return None
+            
+        except Exception as e:
+            print(f"❌ Error creating ZIP file: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+    
+    def download_single_annotations():
+        """Download COCO annotations for single image"""
+        global single_image_annotations, single_image_result, single_image_filename
+        
+        if single_image_annotations is None or single_image_result is None:
+            print("❌ No single image annotation data available")
+            return None
+        
+        try:
+            # Create image info
+            height, width = single_image_result.shape[:2]
+            image_info = {single_image_filename: (height, width)}
+            
+            # Create annotations data in the expected format
+            annotations_data = [(single_image_filename, single_image_annotations)]
+            
+            # Create COCO annotations
+            coco_data = create_coco_annotations(annotations_data, image_info)
+            
+            # Save to temporary file
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            json_filename = f"single_image_annotations_{timestamp}.json"
+            json_path = os.path.join(tempfile.gettempdir(), json_filename)
+            
+            with open(json_path, 'w') as f:
+                json.dump(coco_data, f, indent=2)
+            
+            print(f"💾 Created single image annotations: {json_path}")
+            print(f"📁 File size: {os.path.getsize(json_path)} bytes")
+            
+            # Verify file exists
+            if os.path.exists(json_path) and os.path.getsize(json_path) > 0:
+                return json_path
+            else:
+                print(f"❌ Single image file verification failed: {json_path}")
+                return None
+            
+        except Exception as e:
+            print(f"❌ Error creating single image annotations: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+    
+    def download_single_image():
+        """Download processed single image"""
+        global single_image_result, single_image_filename
+        
+        if single_image_result is None:
+            print("❌ No single image result available")
+            return None
+        
+        try:
+            # Convert to PIL and save
+            pil_image = Image.fromarray(single_image_result.astype('uint8'))
+            
+            # Save to temporary file
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            img_filename = f"processed_image_{timestamp}.jpg"
+            img_path = os.path.join(tempfile.gettempdir(), img_filename)
+            
+            pil_image.save(img_path, 'JPEG', quality=95)
+            
+            print(f"💾 Created single image file: {img_path}")
+            print(f"📁 Image file size: {os.path.getsize(img_path)} bytes")
+            
+            # Verify file exists
+            if os.path.exists(img_path) and os.path.getsize(img_path) > 0:
+                return img_path
+            else:
+                print(f"❌ Single image file verification failed: {img_path}")
+                return None
+            
+        except Exception as e:
+            print(f"❌ Error creating single image file: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+
+    # Connect buttons to functions for single image
+    detect_btn.click(
+        process_single_image,
+        inputs=[input_image, conf_threshold, iou_threshold, line_classes, border_classes, zones_classes],
+        outputs=[input_image, output_image, single_stats_table, single_stats_graph]
+    )
+    clear_btn.click(
+        clear_single,
+        inputs=None,
+        outputs=[input_image, output_image, single_stats_table, single_stats_graph]
+    )
+    
+    # Select All/Unselect All handlers for single image
+    line_select_all.click(
+        fn=lambda: MODEL_CLASSES["Line Detection"],
+        outputs=[line_classes]
+    )
+    line_unselect_all.click(
+        fn=lambda: [],
+        outputs=[line_classes]
+    )
+    border_select_all.click(
+        fn=lambda: MODEL_CLASSES["Border Detection"],
+        outputs=[border_classes]
+    )
+    border_unselect_all.click(
+        fn=lambda: [],
+        outputs=[border_classes]
+    )
+    zones_select_all.click(
+        fn=lambda: MODEL_CLASSES["Zones Detection"],
+        outputs=[zones_classes]
+    )
+    zones_unselect_all.click(
+        fn=lambda: [],
+        outputs=[zones_classes]
+    )
+    
+    # Connect buttons to functions for batch processing
+    process_batch_btn.click(
+        process_batch_images_with_status,
+        inputs=[zip_file, batch_conf_threshold, batch_iou_threshold, batch_line_classes, batch_border_classes, batch_zones_classes],
+        outputs=[batch_gallery, batch_status, batch_stats_table, batch_stats_summary_table, batch_stats_graph]
+    )
+    clear_batch_btn.click(
+        clear_batch,
+        inputs=None,
+        outputs=[zip_file, batch_gallery, batch_status]
+    )
+    
+    # Select All/Unselect All handlers for batch processing
+    batch_line_select_all.click(
+        fn=lambda: MODEL_CLASSES["Line Detection"],
+        outputs=[batch_line_classes]
+    )
+    batch_line_unselect_all.click(
+        fn=lambda: [],
+        outputs=[batch_line_classes]
+    )
+    batch_border_select_all.click(
+        fn=lambda: MODEL_CLASSES["Border Detection"],
+        outputs=[batch_border_classes]
+    )
+    batch_border_unselect_all.click(
+        fn=lambda: [],
+        outputs=[batch_border_classes]
+    )
+    batch_zones_select_all.click(
+        fn=lambda: MODEL_CLASSES["Zones Detection"],
+        outputs=[batch_zones_classes]
+    )
+    batch_zones_unselect_all.click(
+        fn=lambda: [],
+        outputs=[batch_zones_classes]
+    )
+    
+    # Connect download buttons
+    download_json_btn.click(
+        fn=download_annotations,
+        inputs=[],
+        outputs=[json_file_output]
+    )
+    download_zip_btn.click(
+        fn=download_results_zip,
+        inputs=[],
+        outputs=[zip_file_output]
+    )
+    
+    # Connect single image download buttons
+    single_download_json_btn.click(
+        fn=download_single_annotations,
+        inputs=[],
+        outputs=[single_json_output]
+    )
+    single_download_image_btn.click(
+        fn=download_single_image,
+        inputs=[],
+        outputs=[single_image_output]
+    )
+    
+    # Statistics download handlers for single image
+    def download_single_stats_csv():
+        global single_image_annotations, single_image_filename, single_image_selected_classes
+        if single_image_annotations is None:
+            return None
+        stats = calculate_statistics(single_image_annotations, single_image_selected_classes)
+        csv_path = create_statistics_csv(stats, single_image_filename)
+        return csv_path
+    
+    def download_single_stats_json():
+        global single_image_annotations, single_image_filename, single_image_selected_classes
+        if single_image_annotations is None:
+            return None
+        stats = calculate_statistics(single_image_annotations, single_image_selected_classes)
+        json_path = create_statistics_json(stats, single_image_filename)
+        return json_path
+    
+    single_download_stats_csv_btn.click(
+        fn=download_single_stats_csv,
+        inputs=[],
+        outputs=[single_stats_csv_output]
+    )
+    single_download_stats_json_btn.click(
+        fn=download_single_stats_json,
+        inputs=[],
+        outputs=[single_stats_json_output]
+    )
+    
+    # Statistics download handlers for batch processing
+    def download_batch_stats_csv():
+        global current_results, current_batch_selected_classes
+        if not current_results:
+            return None
+        csv_path = create_batch_statistics_csv(current_results, current_batch_selected_classes)
+        return csv_path
+    
+    def download_batch_stats_json():
+        global current_results, current_batch_selected_classes
+        if not current_results:
+            return None
+        json_path = create_batch_statistics_json(current_results, current_batch_selected_classes)
+        return json_path
+    
+    batch_download_stats_csv_btn.click(
+        fn=download_batch_stats_csv,
+        inputs=[],
+        outputs=[batch_stats_csv_output]
+    )
+    batch_download_stats_json_btn.click(
+        fn=download_batch_stats_json,
+        inputs=[],
+        outputs=[batch_stats_json_output]
+    )
+
+if __name__ == "__main__":
+    # Configure launch settings for better stability
+    # Enable Gradio queue for more robust concurrency and error isolation
+    demo.queue()
+    demo.launch(
+        debug=False,  # Disable debug mode for production
+        show_error=True,
+        server_name="0.0.0.0",
+        server_port=8000,
+        share=False,
+        max_threads=4,  # Limit concurrent requests
+        auth=None,
+        inbrowser=False,
+        favicon_path=None,
+        ssl_verify=True,
+        quiet=False
+    )

manifest.json

@@ -0,0 +1,11 @@
+{
+  "name": "Medieval Manuscript Detection",
+  "short_name": "Manuscript Detection",
+  "description": "Medieval Manuscript Detection with Custom YOLO Models",
+  "start_url": "/",
+  "display": "standalone",
+  "background_color": "#ffffff",
+  "theme_color": "#000000",
+  "icons": []
+}
+

utils/data.py

@@ -0,0 +1,417 @@
+from database import (
+    fix_ids,
+    ImageModel,
+    CategoryModel,
+    AnnotationModel,
+    DatasetModel,
+    TaskModel,
+    ExportModel
+)
+
+# import pycocotools.mask as mask
+import numpy as np
+import time
+import json
+import os
+import gc
+
+
+from celery import shared_task
+from ..socket import create_socket
+from mongoengine import Q
+
+
+
+@shared_task
+def export_annotations(task_id, dataset_id, categories, with_empty_images=False):
+
+    task = TaskModel.objects.get(id=task_id)
+    dataset = DatasetModel.objects.get(id=dataset_id)
+
+    task.update(status="PROGRESS")
+    socket = create_socket()
+
+    task.info("Beginning Export (COCO Format)")
+
+    db_categories = CategoryModel.objects(id__in=categories, deleted=False) \
+        .only(*CategoryModel.COCO_PROPERTIES)
+    db_images = ImageModel.objects(
+        deleted=False, dataset_id=dataset.id).only(
+        *ImageModel.COCO_PROPERTIES)
+    db_annotations = AnnotationModel.objects(
+        deleted=False, category_id__in=categories)
+
+    total_items = db_categories.count()
+
+    coco = {
+        'images': [],
+        'categories': [],
+        'annotations': []
+    }
+
+    total_items += db_images.count()
+    progress = 0
+
+    # iterate though all ccategories
+    category_names = []
+    for category in fix_ids(db_categories):
+
+        if len(category.get('keypoint_labels', [])) > 0:
+            category['keypoints'] = category.pop('keypoint_labels', [])
+            category['skeleton'] = category.pop('keypoint_edges', [])
+        else:
+            if 'keypoint_edges' in category:
+                del category['keypoint_edges']
+            if 'keypoint_labels' in category:
+                del category['keypoint_labels']
+
+        task.info(f"Adding category: {category.get('name')}")
+        coco.get('categories').append(category)
+        category_names.append(category.get('name'))
+
+        progress += 1
+        task.set_progress((progress / total_items) * 100, socket=socket)
+
+    total_annotations = db_annotations.count()
+    total_images = db_images.count()
+    for image in db_images:
+        image = fix_ids(image)
+
+        progress += 1
+        task.set_progress((progress / total_items) * 100, socket=socket)
+
+        annotations = db_annotations.filter(image_id=image.get('id'))\
+            .only(*AnnotationModel.COCO_PROPERTIES)
+        annotations = fix_ids(annotations)
+
+        if len(annotations) == 0:
+            if with_empty_images:
+                coco.get('images').append(image)
+            continue
+
+        num_annotations = 0
+        for annotation in annotations:
+
+            has_keypoints = len(annotation.get('keypoints', [])) > 0
+            has_segmentation = len(annotation.get('segmentation', [])) > 0
+
+            if has_keypoints or has_segmentation:
+
+                if not has_keypoints:
+                    if 'keypoints' in annotation:
+                        del annotation['keypoints']
+                else:
+                    arr = np.array(annotation.get('keypoints', []))
+                    arr = arr[2::3]
+                    annotation['num_keypoints'] = len(arr[arr > 0])
+
+                num_annotations += 1
+                coco.get('annotations').append(annotation)
+
+        task.info(
+            f"Exporting {num_annotations} annotations for image {image.get('id')}")
+        coco.get('images').append(image)
+
+    task.info(
+        f"Done export {total_annotations} annotations and {total_images} images from {dataset.name}")
+
+    timestamp = time.time()
+    directory = f"{dataset.directory}.exports/"
+    file_path = f"{directory}coco-{timestamp}.json"
+
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+    task.info(f"Writing export to file {file_path}")
+    with open(file_path, 'w') as fp:
+        json.dump(coco, fp)
+
+    task.info("Creating export object")
+    export = ExportModel(dataset_id=dataset.id, path=file_path, tags=[
+                         "COCO", *category_names])
+    export.save()
+
+    task.set_progress(100, socket=socket)
+
+
+def process_coco_file(coco_json,task,socket,dataset,images,categories):
+    coco_images = coco_json.get('images', [])
+    coco_annotations = coco_json.get('annotations', [])
+    coco_categories = coco_json.get('categories', [])
+
+    task.info(f"Importing {len(coco_categories)} categories, "
+              f"{len(coco_images)} images, and "
+              f"{len(coco_annotations)} annotations")
+
+    total_items = sum([
+        len(coco_categories),
+        len(coco_annotations),
+        len(coco_images)
+    ])
+    progress = 0
+
+    task.info("===== Importing Categories =====")
+    # category id mapping  ( file : database )
+    categories_id = {}
+
+    # Create any missing categories
+    for category in coco_categories:
+
+        category_name = category.get('name')
+        category_id = category.get('id')
+        category_model = categories.filter(name__iexact=category_name).first()
+
+        if category_model is None:
+            task.warning(
+                f"{category_name} category not found (creating a new one)")
+
+            new_category = CategoryModel(
+                name=category_name,
+                keypoint_edges=category.get('skeleton', []),
+                keypoint_labels=category.get('keypoints', [])
+            )
+            new_category.save()
+
+            category_model = new_category
+            dataset.categories.append(new_category.id)
+
+        task.info(f"{category_name} category found")
+        # map category ids
+        categories_id[category_id] = category_model.id
+
+        # update progress
+        progress += 1
+        task.set_progress((progress / total_items) * 100, socket=socket)
+
+    dataset.update(set__categories=dataset.categories)
+
+    task.info("===== Loading Images =====")
+    # image id mapping ( file: database )
+    images_id = {}
+    categories_by_image = {}
+
+    # Find all images
+    for image in coco_images:
+        image_id = image.get('id')
+        image_filename = image.get('file_name')
+
+        # update progress
+        progress += 1
+        task.set_progress((progress / total_items) * 100, socket=socket)
+
+        image_model = images.filter(file_name__exact=image_filename).all()
+
+        if len(image_model) == 0:
+            task.warning(f"Could not find image {image_filename}")
+            continue
+
+        if len(image_model) > 1:
+            task.error(
+                f"Too many images found with the same file name: {image_filename}")
+            continue
+
+        task.info(f"Image {image_filename} found")
+        image_model = image_model[0]
+        images_id[image_id] = image_model
+        categories_by_image[image_id] = list()
+
+    task.info("===== Import Annotations =====")
+    for annotation in coco_annotations:
+
+        image_id = annotation.get('image_id')
+        category_id = annotation.get('category_id')
+        segmentation = annotation.get('segmentation', [])
+        keypoints = annotation.get('keypoints', [])
+        # is_crowd = annotation.get('iscrowed', False)
+        area = annotation.get('area', 0)
+        bbox = annotation.get('bbox', [0, 0, 0, 0])
+        isbbox = annotation.get('isbbox', False)
+
+        progress += 1
+        task.set_progress((progress / total_items) * 100, socket=socket)
+
+        has_segmentation = len(segmentation) > 0
+        has_keypoints = len(keypoints) > 0
+        if not has_segmentation and not has_keypoints:
+           task.warning(
+               f"Annotation {annotation.get('id')} has no segmentation or keypoints, but bbox {bbox}")
+           #continue
+
+        try:
+            image_model = images_id[image_id]
+            category_model_id = categories_id[category_id]
+            image_categories = categories_by_image[image_id]
+        except KeyError:
+            task.warning(
+                f"Could not find image assoicated with annotation {annotation.get('id')}")
+            continue
+
+        annotation_model = AnnotationModel.objects(
+            image_id=image_model.id,
+            category_id=category_model_id,
+            segmentation=segmentation,
+            keypoints=keypoints
+        ).first()
+
+        if annotation_model is None:
+            task.info(f"Creating annotation data ({image_id}, {category_id})")
+
+            annotation_model = AnnotationModel(image_id=image_model.id)
+            annotation_model.category_id = category_model_id
+
+            annotation_model.color = annotation.get('color')
+            annotation_model.metadata = annotation.get('metadata', {})
+            annotation_model.area = area
+            annotation_model.bbox = bbox
+            
+            if has_segmentation:
+                annotation_model.segmentation = segmentation
+            else:
+                task.warning(
+               f"Annotation {annotation.get('id')} has no segmentation. Creating one from bbox {bbox}")
+
+                x_min, y_min, width, height = bbox
+                x_max = x_min + width
+                y_max = y_min + height
+                segments = [
+                    x_max, y_min,  # Top-right corner
+                    x_max, y_max,  # Bottom-right corner
+                    x_min, y_max,  # Bottom-left corner
+                    x_min, y_min   # Top-left corner
+                ]
+
+                annotation_model.segmentation = segments
+
+            if has_keypoints:
+                annotation_model.keypoints = keypoints
+
+            annotation_model.isbbox = isbbox
+            annotation_model.save()
+
+            image_categories.append(category_id)
+        else:
+            annotation_model.update(deleted=False, isbbox=isbbox)
+            task.info(
+                f"Annotation already exists (i:{image_id}, c:{category_id})")
+
+    for image_id in images_id:
+        image_model = images_id[image_id]
+        category_ids = categories_by_image[image_id]
+        all_category_ids = list(image_model.category_ids)
+        all_category_ids += category_ids
+
+        num_annotations = AnnotationModel.objects(
+            Q(image_id=image_id) & Q(deleted=False) &
+            (Q(area__gt=0) | Q(keypoints__size__gt=0))
+        ).count()
+
+        image_model.update(
+            set__annotated=True,
+            set__category_ids=list(set(all_category_ids)),
+            set__num_annotations=num_annotations
+        )
+
+    task.set_progress(100, socket=socket)
+
+
+@shared_task
+def import_annotations(task_id, dataset_id, coco_json):
+
+    task = TaskModel.objects.get(id=task_id)
+    dataset = DatasetModel.objects.get(id=dataset_id)
+
+    task.update(status="PROGRESS")
+    socket = create_socket()
+
+    task.info("Beginning Import")
+
+    images = ImageModel.objects(dataset_id=dataset.id)
+    categories = CategoryModel.objects
+
+    process_coco_file(coco_json,task,socket,dataset,images,categories)
+
+
+@shared_task
+def predict_annotations(task_id, model_name, image_path,image_id,dict_labels_folders):
+    from ultralytics import YOLO
+
+    if model_name=='emanuskript':
+        emanuskript_classes = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,20]
+        model = YOLO("workers/best_emanuskript_segmentation.onnx",task='segment')
+        results = model.predict(image_path,classes = emanuskript_classes,
+                                                    iou=0.3,device='cpu',augment=False,stream=False)
+    
+    elif model_name=='catmus':
+        catmus_classes=[1,7]
+        model = YOLO("workers/best_catmus.onnx",task='segment')
+        results = model.predict(image_path,classes = catmus_classes,
+                                iou=0.3,device='cpu',augment=False,stream=False)
+    elif model_name=='zone':
+        model = YOLO("workers/best_zone_detection.pt")
+        results = model.predict(image_path,device='cpu',
+                                                iou=0.3,
+                                                augment=False,stream=False)
+    else:
+        raise Exception('Model name must be one of emanuskript, catmus or zone')
+    
+    # get the images to apply the model
+    task = TaskModel.objects.get(id=task_id)
+    
+    # Save labels
+    result = results[0]
+    prediction_path = f'{dict_labels_folders[model_name]}/{image_id}.json'
+    with open(prediction_path,'w') as f:
+        f.write(result.tojson())
+
+    task.info(f'Labels predicted in : {prediction_path}')
+    task.update(status="COMPLETED")
+    del model
+    del result
+    del results
+    gc.collect() 
+    return 1
+
+
+
+@shared_task
+def unify_predictions(results, task_id, dataset_id, images_path,dict_labels_folders):
+    
+    #Results is unused by necessary for Celery Chord
+    from .image_batch_classes import ImageBatch
+
+    task = TaskModel.objects.get(id=task_id)
+    task.info(f'Starts prediction unification')
+    dataset = DatasetModel.objects.get(id=dataset_id)
+
+    image_batch = ImageBatch(
+        image_folder=images_path,
+        catmus_labels_folder=dict_labels_folders['catmus'],
+        emanuskript_labels_folder=dict_labels_folders['emanuskript'],
+        zone_labels_folder=dict_labels_folders['zone']
+    )
+    image_batch.load_images()
+    image_batch.load_annotations()
+    image_batch.unify_names()
+    coco_json = image_batch.return_coco_file()
+    task.info(f'COCO Json file created')
+
+    # Update task status
+    task.update(status="PROGRESS")
+    socket = create_socket()
+
+    images = ImageModel.objects(dataset_id=dataset_id)
+    categories = CategoryModel.objects
+
+    total_images = images.count()
+    task.info(f"Found {total_images} images to process")
+
+
+    process_coco_file(coco_json,task,socket,dataset,images,categories)
+
+
+
+
+
+
+
+__all__ = ["export_annotations", "import_annotations","predict_annotations","unify_predictions"]

utils/database/__init__.py

@@ -0,0 +1,73 @@
+from mongoengine import connect
+from config import Config
+
+from .annotations import *
+from .categories import *
+from .datasets import *
+from .lisence import *
+from .exports import *
+from .images import *
+from .events import *
+from .users import *
+from .tasks import *
+
+import json
+
+
+def connect_mongo(name, host=None):
+    if host is None:
+        host = Config.MONGODB_HOST
+    connect(name, host=host)
+
+
+# https://github.com/MongoEngine/mongoengine/issues/1171
+# Use this methods until a solution is found
+def upsert(model, query=None, update=None):
+
+    if not update:
+        update = query
+
+    if not query:
+        return None
+
+    found = model.objects(**query)
+
+    if found.first():
+        return found.modify(new=True, **update)
+
+    new_model = model(**update)
+    new_model.save()
+
+    return new_model
+
+
+def fix_ids(q):
+    json_obj = json.loads(q.to_json().replace('\"_id\"', '\"id\"'))
+    return json_obj
+
+
+def create_from_json(json_file):
+
+    with open(json_file) as file:
+
+        data_json = json.load(file)
+        for category in data_json.get('categories', []):
+            name = category.get('name')
+            if name is not None:
+                upsert(CategoryModel, query={"name": name}, update=category)
+
+        for dataset_json in data_json.get('datasets', []):
+            name = dataset_json.get('name')
+            if name:
+                # map category names to ids; create as needed
+                category_ids = []
+                for category in dataset_json.get('categories', []):
+                    category_obj = {"name": category}
+
+                    category_model = upsert(CategoryModel, query=category_obj)
+                    category_ids.append(category_model.id)
+
+                dataset_json['categories'] = category_ids
+                upsert(DatasetModel, query={ "name": name}, update=dataset_json)
+
+

utils/database/annotations.py

@@ -0,0 +1,123 @@
+import imantics as im
+import json
+
+from mongoengine import *
+
+from .datasets import DatasetModel
+from .categories import CategoryModel
+from .events import Event
+from flask_login import current_user
+import numpy as np
+import cv2
+
+
+class AnnotationModel(DynamicDocument):
+
+    COCO_PROPERTIES = ["id", "image_id", "category_id", "segmentation",
+                       "iscrowd", "color", "area", "bbox", "metadata",
+                       "keypoints", "isbbox"]
+
+    id = SequenceField(primary_key=True)
+    image_id = IntField(required=True)
+    category_id = IntField(required=True)
+    dataset_id = IntField()
+
+    segmentation = ListField(default=[])
+    area = IntField(default=0)
+    bbox = ListField(default=[0, 0, 0, 0])
+    iscrowd = BooleanField(default=False)
+    isbbox = BooleanField(default=False)
+
+    creator = StringField(required=True)
+    width = IntField()
+    height = IntField()
+
+    color = StringField()
+
+    keypoints = ListField(default=[])
+
+    metadata = DictField(default={})
+    paper_object = ListField(default=[])
+
+    deleted = BooleanField(default=False)
+    deleted_date = DateTimeField()
+
+    milliseconds = IntField(default=0)
+    events = EmbeddedDocumentListField(Event)
+
+    def __init__(self, image_id=None, **data):
+
+        from .images import ImageModel
+
+        if image_id is not None:
+            image = ImageModel.objects(id=image_id).first()
+
+            if image is not None:
+                data['image_id'] = image_id
+                data['width'] = image.width
+                data['height'] = image.height
+                data['dataset_id'] = image.dataset_id
+
+        super(AnnotationModel, self).__init__(**data)
+
+    def save(self, copy=False, *args, **kwargs):
+
+        if self.dataset_id and not copy:
+            dataset = DatasetModel.objects(id=self.dataset_id).first()
+
+            if dataset is not None:
+                self.metadata = dataset.default_annotation_metadata.copy()
+
+        if self.color is None:
+            self.color = im.Color.random().hex
+
+        if current_user:
+            self.creator = current_user.username
+        else:
+            self.creator = 'system'
+
+        return super(AnnotationModel, self).save(*args, **kwargs)
+
+    def is_empty(self):
+        return len(self.segmentation) == 0 or self.area == 0
+
+    def mask(self):
+        """ Returns binary mask of annotation """
+        mask = np.zeros((self.height, self.width))
+        pts = [
+            np.array(anno).reshape(-1, 2).round().astype(int)
+            for anno in self.segmentation
+        ]
+        mask = cv2.fillPoly(mask, pts, 1)
+        return mask
+
+    def clone(self):
+        """ Creates a clone """
+        create = json.loads(self.to_json())
+        del create['_id']
+
+        return AnnotationModel(**create)
+
+    def __call__(self):
+
+        category = CategoryModel.objects(id=self.category_id).first()
+        if category:
+            category = category()
+
+        data = {
+            'image': None,
+            'category': category,
+            'color': self.color,
+            'polygons': self.segmentation,
+            'width': self.width,
+            'height': self.height,
+            'metadata': self.metadata
+        }
+
+        return im.Annotation(**data)
+
+    def add_event(self, e):
+        self.update(push__events=e)
+
+
+__all__ = ["AnnotationModel"]

utils/database/categories.py

@@ -0,0 +1,83 @@
+
+from flask_login import current_user
+from mongoengine import *
+
+import imantics as im
+
+
+class CategoryModel(DynamicDocument):
+
+    COCO_PROPERTIES = ["id", "name", "supercategory", "color", "metadata",\
+                       "keypoint_edges", "keypoint_labels", "keypoint_colors"]
+
+    id = SequenceField(primary_key=True)
+    name = StringField(required=True, unique_with=['creator'])
+    supercategory = StringField(default='')
+    color = StringField(default=None)
+    metadata = DictField(default={})
+
+    creator = StringField(default='unknown')
+    deleted = BooleanField(default=False)
+    deleted_date = DateTimeField()
+
+    keypoint_edges = ListField(default=[])
+    keypoint_labels = ListField(default=[])
+    keypoint_colors = ListField(default=[])
+
+    @classmethod
+    def bulk_create(cls, categories):
+
+        if not categories:
+            return []
+
+        category_ids = []
+        for category in categories:
+            category_model = CategoryModel.objects(name=category).first()
+
+            if category_model is None:
+                new_category = CategoryModel(name=category)
+                new_category.save()
+                category_ids.append(new_category.id)
+            else:
+                category_ids.append(category_model.id)
+
+        return category_ids
+
+    def save(self, *args, **kwargs):
+
+        if not self.color:
+            self.color = im.Color.random().hex
+
+        if current_user:
+            self.creator = current_user.username
+        else:
+            self.creator = 'system'
+      
+        return super(CategoryModel, self).save(*args, **kwargs)
+
+    def __call__(self):
+        """ Generates imantics category object """
+        data = {
+            'name': self.name,
+            'color': self.color,
+            'parent': self.supercategory,
+            'metadata': self.metadata,
+            'id': self.id
+        }
+        return im.Category(**data)
+    
+    def is_owner(self, user):
+
+        if user.is_admin:
+            return True
+        
+        return user.username.lower() == self.creator.lower()
+    
+    def can_edit(self, user):
+        return self.is_owner(user)
+    
+    def can_delete(self, user):
+        return self.is_owner(user)
+
+
+__all__ = ["CategoryModel"]

utils/database/datasets.py

@@ -0,0 +1,204 @@
+
+from flask_login import current_user
+from mongoengine import *
+from config import Config
+
+from .tasks import TaskModel
+
+import os
+
+
+class DatasetModel(DynamicDocument):
+    
+    id = SequenceField(primary_key=True)
+    name = StringField(required=True, unique=True)
+    directory = StringField()
+    thumbnails = StringField()
+    categories = ListField(default=[])
+
+    owner = StringField(required=True)
+    users = ListField(default=[])
+
+    annotate_url = StringField(default="")
+
+    default_annotation_metadata = DictField(default={})
+
+    deleted = BooleanField(default=False)
+    deleted_date = DateTimeField()
+
+    def save(self, *args, **kwargs):
+
+        directory = os.path.join(Config.DATASET_DIRECTORY, self.name + '/')
+        os.makedirs(directory, mode=0o777, exist_ok=True)
+
+        self.directory = directory
+        self.owner = current_user.username if current_user else 'system'
+
+        return super(DatasetModel, self).save(*args, **kwargs)
+
+    def get_users(self):
+        from .users import UserModel
+    
+        members = self.users
+        members.append(self.owner)
+
+        return UserModel.objects(username__in=members)\
+            .exclude('password', 'id', 'preferences')
+
+    def import_coco(self, coco_json):
+
+        from workers.tasks import import_annotations
+
+        task = TaskModel(
+            name="Import COCO format into {}".format(self.name),
+            dataset_id=self.id,
+            group="Annotation Import"
+        )
+        task.save()
+
+        cel_task = import_annotations.delay(task.id, self.id, coco_json)
+
+        return {
+            "celery_id": cel_task.id,
+            "id": task.id,
+            "name": task.name
+        }
+
+
+    def predict_coco(self):
+
+        from workers.tasks import predict_annotations,unify_predictions
+        from celery import chord
+
+        # Setup
+        #TODO Get images from the image model
+        images_path = self.directory
+
+        catmus_labels_folder = os.path.join(images_path, 'labels', 'catmus')
+        emanuskript_labels_folder = os.path.join(images_path, 'labels', 'emanuskript')
+        zone_detection_labels_folder = os.path.join(images_path, 'labels', 'zone_detection')
+
+        dict_labels_folders = {'catmus':catmus_labels_folder,
+                            'emanuskript':emanuskript_labels_folder,
+                            'zone':zone_detection_labels_folder}
+
+        for label_path in [dict_labels_folders['catmus'],dict_labels_folders['emanuskript'],dict_labels_folders['zone']]:
+            os.makedirs(label_path,exist_ok=True)
+
+        #Predict 
+        
+        image_files = [f for f in os.listdir(images_path) if f.lower().endswith(('.jpg', '.jpeg', '.png'))]
+
+        prediction_tasks = []
+
+        for image_path in image_files:
+            image_id = os.path.splitext(os.path.basename(image_path))[0]
+            image_full_path = os.path.join(images_path, image_path)
+            for model in dict_labels_folders.keys():
+
+                task = TaskModel(
+                    name=f"Predicting {model} annotations for {image_id}",
+                    dataset_id=self.id,
+                    group="Annotation Prediction"
+                )
+                task.save()
+                prediction_tasks.append(predict_annotations.s(task.id, model, image_full_path,image_id,dict_labels_folders))
+
+        # List to hold the task details for each image
+        
+        unify_task = TaskModel(
+            name=f"Unifying annotations for dataset {self.name}",
+            dataset_id=self.id,
+            group="Annotation Prediction"
+        )
+        unify_task.save()
+
+        # This task will be triggered after all image predictions are completed
+        unify_task_signature = unify_predictions.s(unify_task.id, self.id, images_path, dict_labels_folders)
+
+        # Use Celery `chord` to handle the parallel predictions and trigger unification
+
+        chord(prediction_tasks)(unify_task_signature)
+
+        return {
+            "unify_task_id": unify_task.id,
+            
+        }
+
+
+
+    def export_coco(self, categories=None, style="COCO", with_empty_images=False):
+
+        from workers.tasks import export_annotations
+
+        if categories is None or len(categories) == 0:
+            categories = self.categories
+
+        task = TaskModel(
+            name=f"Exporting {self.name} into {style} format",
+            dataset_id=self.id,
+            group="Annotation Export"
+        )
+        task.save()
+
+        cel_task = export_annotations.delay(task.id, self.id, categories, with_empty_images)
+
+        return {
+            "celery_id": cel_task.id,
+            "id": task.id,
+            "name": task.name
+        }
+
+    def scan(self):
+
+        from workers.tasks import scan_dataset
+        
+        task = TaskModel(
+            name=f"Scanning {self.name} for new images",
+            dataset_id=self.id,
+            group="Directory Image Scan"
+        )
+        task.save()
+        
+        cel_task = scan_dataset.delay(task.id, self.id)
+
+        return {
+            "celery_id": cel_task.id,
+            "id": task.id,
+            "name": task.name
+        }
+
+    def is_owner(self, user):
+
+        if user.is_admin:
+            return True
+        
+        return user.username.lower() == self.owner.lower()
+
+    def can_download(self, user):
+        return self.is_owner(user)
+
+    def can_delete(self, user):
+        return self.is_owner(user)
+    
+    def can_share(self, user):
+        return self.is_owner(user)
+    
+    def can_generate(self, user):
+        return self.is_owner(user)
+
+    def can_edit(self, user):
+        return user.username in self.users or self.is_owner(user)
+    
+    def permissions(self, user):
+        return {
+            'owner': self.is_owner(user),
+            'edit': self.can_edit(user),
+            'share': self.can_share(user),
+            'generate': self.can_generate(user),
+            'delete': self.can_delete(user),
+            'download': self.can_download(user)
+        }
+
+
+__all__ = ["DatasetModel"]

utils/database/events.py

@@ -0,0 +1,36 @@
+from mongoengine import *
+
+import datetime
+import time
+
+
+class Event(EmbeddedDocument):
+    
+    name = StringField()
+    created_at = DateTimeField()
+
+    meta = {'allow_inheritance': True}
+
+    def now(self, event):
+        self.created_at = datetime.datetime.now()
+
+
+class SessionEvent(Event):
+
+    user = StringField(required=True)
+    milliseconds = IntField(default=0, min_value=0)
+    tools_used = ListField(default=[])
+
+    @classmethod
+    def create(self, start, user, end=None, tools=[]):
+
+        if end is None:
+            end = time.time()
+
+        return SessionEvent(
+            user=user.username,
+            milliseconds=int((end-start)*1000)
+        )
+
+
+__all__ = ["Event", "SessionEvent"]

utils/database/exports.py

@@ -0,0 +1,20 @@
+from mongoengine import *
+
+import datetime
+import time
+
+
+class ExportModel(DynamicDocument):
+    
+    id = SequenceField(primary_key=True)
+    dataset_id = IntField(required=True)
+    path = StringField(required=True)
+    tags = ListField(default=[])
+    categories = ListField(default=[])
+    created_at = DateTimeField(default=datetime.datetime.utcnow)
+    
+    def get_file(self):
+        return
+
+
+__all__ = ["ExportModel"]

utils/database/images.py

@@ -0,0 +1,248 @@
+import os
+import numpy as np
+import cv2
+import imantics as im
+
+
+from PIL import Image, ImageFile
+from mongoengine import *
+
+from .events import Event, SessionEvent
+from .datasets import DatasetModel
+from .annotations import AnnotationModel
+
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+
+class ImageModel(DynamicDocument):
+
+    COCO_PROPERTIES = ["id", "width", "height", "file_name", "path", "license",\
+                       "flickr_url", "coco_url", "date_captured", "dataset_id"]
+
+    # -- Contants
+    THUMBNAIL_DIRECTORY = '.thumbnail'
+    PATTERN = (".gif", ".png", ".jpg", ".jpeg", ".bmp", ".tif", ".tiff", ".GIF", ".PNG", ".JPG", ".JPEG", ".BMP", ".TIF", ".TIFF")
+
+    # Set maximum thumbnail size (h x w) to use on dataset page
+    MAX_THUMBNAIL_DIM = (1024, 1024)
+
+    # -- Private
+    _dataset = None
+
+    # -- Database
+    id = SequenceField(primary_key=True)
+    dataset_id = IntField(required=True)
+    category_ids = ListField(default=[])
+
+    # Absolute path to image file
+    path = StringField(required=True, unique=True)
+    width = IntField(required=True)
+    height = IntField(required=True)
+    file_name = StringField()
+    
+    # True if the image is annotated
+    annotated = BooleanField(default=False)
+    # Poeple currently annotation the image
+    annotating = ListField(default=[])
+    num_annotations = IntField(default=0)
+    
+    thumbnail_url = StringField()
+    image_url = StringField()
+    coco_url = StringField()
+    date_captured = DateTimeField()
+
+    metadata = DictField()
+    license = IntField()
+
+    deleted = BooleanField(default=False)
+    deleted_date = DateTimeField()
+
+    milliseconds = IntField(default=0)
+    events = EmbeddedDocumentListField(Event)
+    regenerate_thumbnail = BooleanField(default=False)
+
+    @classmethod
+    def create_from_path(cls, path, dataset_id=None):
+
+        pil_image = Image.open(path)
+
+        image = cls()
+        image.file_name = os.path.basename(path)
+        image.path = path
+        image.width = pil_image.size[0]
+        image.height = pil_image.size[1]
+        image.regenerate_thumbnail = True
+
+        if dataset_id is not None:
+            image.dataset_id = dataset_id
+        else:
+            # Get dataset name from path
+            folders = path.split('/')
+            i = folders.index("datasets")
+            dataset_name = folders[i+1]
+
+            dataset = DatasetModel.objects(name=dataset_name).first()
+            if dataset is not None:
+                image.dataset_id = dataset.id
+
+        pil_image.close()
+
+        return image
+
+    def delete(self, *args, **kwargs):
+        self.thumbnail_delete()
+        AnnotationModel.objects(image_id=self.id).delete()
+        return super(ImageModel, self).delete(*args, **kwargs)
+
+    def thumbnail(self):
+        """
+        Generates (if required) thumbnail
+        """
+        
+        thumbnail_path = self.thumbnail_path()
+
+        if self.regenerate_thumbnail:
+
+            pil_image = self.generate_thumbnail()
+            pil_image = pil_image.convert("RGB")
+
+            # Resize image to fit in MAX_THUMBNAIL_DIM envelope as necessary
+            pil_image.thumbnail((self.MAX_THUMBNAIL_DIM[1], self.MAX_THUMBNAIL_DIM[0]))
+
+            # Save as a jpeg to improve loading time
+            # (note file extension will not match but allows for backwards compatibility)
+            pil_image.save(thumbnail_path, "JPEG", quality=80, optimize=True, progressive=True)
+
+            self.update(is_modified=False)
+            return pil_image
+
+    def open_thumbnail(self):
+        """
+        Return thumbnail
+        """
+        thumbnail_path = self.thumbnail_path()
+        return Image.open(thumbnail_path)
+
+    def thumbnail_path(self):
+        folders = self.path.split('/')
+        folders.insert(len(folders)-1, self.THUMBNAIL_DIRECTORY)
+
+        path = '/' + os.path.join(*folders)
+        directory = os.path.dirname(path)
+
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+        
+        return path
+    
+    def thumbnail_delete(self):
+        path = self.thumbnail_path()
+        if os.path.isfile(path):
+            os.remove(path)
+
+    def generate_thumbnail(self):
+        # Get the image
+        image = self()
+
+        # Check if the image has a 'draw' method
+        if hasattr(image, 'draw'):
+            # Call the 'draw' method if it exists
+            image = image.draw(color_by_category=True, bbox=False)
+        
+        # Check if the image is already a NumPy array
+        if isinstance(image, np.ndarray):
+            # Convert NumPy array to PIL image
+            return Image.fromarray(image)
+        else:
+            # If the image is not a NumPy array, return it as is (assuming it's already a PIL Image object)
+            print("Returning the original image as it is not a NumPy array.")
+            return image
+
+    def flag_thumbnail(self, flag=True):
+        """
+        Toggles values to regenerate thumbnail on next thumbnail request
+        """
+        if self.regenerate_thumbnail != flag:
+            self.update(regenerate_thumbnail=flag)
+
+    def copy_annotations(self, annotations):
+        """
+        Creates a copy of the annotations for this image
+        :param annotations: QuerySet of annotation models
+        :return: number of annotations
+        """
+        annotations = annotations.filter(
+            width=self.width, height=self.height).exclude('events')
+
+        for annotation in annotations:
+            if annotation.area > 0 or len(annotation.keypoints) > 0:
+                clone = annotation.clone()
+
+                clone.dataset_id = self.dataset_id
+                clone.image_id = self.id
+
+                clone.save(copy=True)
+
+        return annotations.count()
+
+    @property
+    def dataset(self):
+        if self._dataset is None:
+            self._dataset = DatasetModel.objects(id=self.dataset_id).first()
+        return self._dataset
+
+
+
+    def __call__(self):
+        print('ENTERS HERE for this path:', self.path)
+
+        # Check if the file exists before trying to load it
+        if os.path.exists(self.path):
+            # Try to load the image using OpenCV
+            brg = cv2.imread(self.path)
+            
+            if brg is not None:
+                # If the image is successfully loaded, proceed with annotations
+                image = im.Image.from_path(self.path)
+
+                for annotation in AnnotationModel.objects(image_id=self.id, deleted=False).all():
+                    if not annotation.is_empty():
+                        image.add(annotation())
+
+            else:
+                # Handle the case where the file exists but cannot be loaded (e.g., unsupported format)
+                print(f"File at path {self.path} cannot be loaded. Returning a blank image.")
+                image = Image.new("RGB", (512, 512), (255, 255, 255))  # Modify size/color as needed
+        else:
+            # Handle the case where the file does not exist
+            print(f"No image found at path: {self.path}. Returning a blank image.")
+            image = Image.new("RGB", (512, 512), (255, 255, 255))  # Modify size/color as needed
+
+        return image
+
+    
+    def can_delete(self, user):
+        return user.can_delete(self.dataset)
+    
+    def can_download(self, user):
+        return user.can_download(self.dataset)
+    
+    # TODO: Fix why using the functions throws an error
+    def permissions(self, user):
+        return {
+            'delete': True,
+            'download': True
+        }
+    
+    def add_event(self, e):
+        u = {
+            'push__events': e,
+        }
+        if isinstance(e, SessionEvent):
+            u['inc__milliseconds'] = e.milliseconds
+
+        self.update(**u)
+
+
+__all__ = ["ImageModel"]

utils/database/lisence.py

@@ -0,0 +1,10 @@
+from mongoengine import *
+
+
+class LicenseModel(DynamicDocument):
+    id = SequenceField(primary_key=True)
+    name = StringField()
+    url = StringField()
+
+
+__all__ = ["LicenseModel"]

utils/database/tasks.py

@@ -0,0 +1,99 @@
+from mongoengine import *
+
+import datetime
+
+
+class TaskModel(DynamicDocument):
+    id = SequenceField(primary_key=True)
+    
+    # Type of task: Importer, Exporter, Scanner, etc.
+    group = StringField(required=True)
+    name = StringField(required=True) 
+    desciption = StringField()
+    status = StringField(default="PENDING")
+    creator = StringField()
+
+    #: Start date of the executor 
+    start_date = DateTimeField()
+    #: End date of the executor 
+    end_date = DateTimeField()
+    completed = BooleanField(default=False)
+    failed = BooleanField(default=False)
+    has_download = BooleanField(default=False)
+    
+    # If any of the information is relevant to the task
+    # it should be added
+    dataset_id = IntField()
+    image_id = IntField()
+    category_id = IntField()
+
+    progress = FloatField(default=0, min_value=0, max_value=100)
+
+    logs = ListField(default=[])
+    errors = IntField(default=0)
+    warnings = IntField(default=0)
+
+    priority = IntField()
+
+    metadata = DictField(default={})
+
+    _update_every = 10
+    _progress_update = 0
+
+    def error(self, string):
+        self._log(string, level="ERROR")
+    
+    def warning(self, string):
+        self._log(string, level="WARNING")
+    
+    def info(self, string):
+        self._log(string, level="INFO")
+    
+    def _log(self, string, level):
+
+        level = level.upper()
+        date = datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%S")
+        
+        message = f"[{date}] [{level}] {string}"
+
+        statment = {
+            'push__logs': message
+        }
+
+        if level == "ERROR":
+            statment['inc__errors'] = 1
+            self.errors += 1
+        
+        if level == "WARNING":
+            statment['inc__warnings'] = 1
+            self.warnings += 1
+
+        self.update(**statment)
+
+    def set_progress(self, percent, socket=None):
+
+        self.update(progress=int(percent), completed=(percent >= 100))
+
+        # Send socket update every 10%
+        if self._progress_update < percent or percent >= 100:
+            
+            if socket is not None:
+                # logger.debug(f"Emitting {percent} progress update for task {self.id}")
+
+                socket.emit('taskProgress', {
+                    'id': self.id,
+                    'progress': percent,
+                    'errors': self.errors,
+                    'warnings': self.warnings
+                }, broadcast=True)
+            
+            self._progress_update += self._update_every
+    
+    def api_json(self):
+        return {
+            "id": self.id,
+            "name": self.name
+        }
+
+
+__all__ = ["TaskModel"]

utils/database/users.py

@@ -0,0 +1,96 @@
+import datetime
+
+from mongoengine import *
+from flask_login import UserMixin
+
+from .annotations import AnnotationModel
+from .categories import CategoryModel
+from .datasets import DatasetModel
+from .images import ImageModel
+
+
+class UserModel(DynamicDocument, UserMixin):
+
+    password = StringField(required=True)
+    username = StringField(max_length=25, required=True, unique=True)
+    email = StringField(max_length=30)
+
+    name = StringField()
+    online = BooleanField(default=False)
+    last_seen = DateTimeField()
+
+    is_admin = BooleanField(default=False)
+
+    preferences = DictField(default={})
+    permissions = ListField(defualt=[])
+
+    # meta = {'allow_inheritance': True}
+
+    @property
+    def datasets(self):
+        self._update_last_seen()
+
+        if self.is_admin:
+            return DatasetModel.objects
+
+        return DatasetModel.objects(Q(owner=self.username) | Q(users__contains=self.username))
+
+    @property
+    def categories(self):
+        self._update_last_seen()
+
+        if self.is_admin:
+            return CategoryModel.objects
+
+        dataset_ids = self.datasets.distinct('categories')
+        return CategoryModel.objects(Q(id__in=dataset_ids) | Q(creator=self.username))
+
+    @property
+    def images(self):
+        self._update_last_seen()
+
+        if self.is_admin:
+            return ImageModel.objects
+
+        dataset_ids = self.datasets.distinct('id')
+        return ImageModel.objects(dataset_id__in=dataset_ids)
+
+    @property
+    def annotations(self):
+        self._update_last_seen()
+
+        if self.is_admin:
+            return AnnotationModel.objects
+
+        image_ids = self.images.distinct('id')
+        return AnnotationModel.objects(image_id__in=image_ids)
+
+    def can_view(self, model):
+        if model is None:
+            return False
+
+        return model.can_view(self)
+    
+    def can_download(self, model):
+        if model is None:
+            return False
+
+        return model.can_download(self)
+        
+    def can_delete(self, model):
+        if model is None:
+            return False
+        return model.can_delete(self)
+
+    def can_edit(self, model):
+        if model is None:
+            return False
+
+        return model.can_edit(self)
+
+    def _update_last_seen(self):
+        self.update(last_seen=datetime.datetime.utcnow())
+    
+
+
+__all__ = ["UserModel"]

utils/image_batch_classes.py

@@ -0,0 +1,417 @@
+from pathlib import Path
+import json
+import numpy as np
+from PIL import Image as PILImage
+import os
+from rtree import index
+from shapely.geometry import box
+
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+
+
+# Constants for category mappings
+catmus_zones_mapping = {
+    'DefaultLine': 'Main script black',
+    'InterlinearLine': 'Gloss',
+        'MainZone': 'Column',
+    'DropCapitalZone': 'Plain initial- coloured',
+     'StampZone': 'Illustrations',
+    'GraphicZone': 'Illustrations',
+    'MarginTextZone': 'Gloss',
+    'MusicZone': 'Music',
+    'NumberingZone': 'Page Number',
+    'QuireMarksZone': 'Quire Mark',
+    'RunningTitleZone': 'Running header',
+    'TitlePageZone': 'Column'
+}
+
+coco_class_mapping = {
+    'Border': 1,
+    'Table': 2,
+    'Diagram': 3,
+    'Main script black': 4,
+    'Main script coloured': 5,
+    'Variant script black': 6,
+    'Variant script coloured': 7,
+    'Historiated': 8,
+    'Inhabited': 9,
+    'Zoo - Anthropomorphic': 10,
+    'Embellished': 11,
+    'Plain initial- coloured': 12,
+    'Plain initial - Highlighted': 13,
+    'Plain initial - Black': 14,
+    'Page Number': 15,
+    'Quire Mark': 16,
+    'Running header': 17,
+    'Catchword': 18,
+    'Gloss': 19,
+    'Illustrations': 20,
+    'Column': 21,
+    'GraphicZone': 22,
+    'MusicLine': 23,
+    'MusicZone': 24,
+    'Music': 25
+}
+
+
+class Annotation:
+    def __init__(self, annotation, image):
+        self.name = annotation['name']
+        self.cls = annotation['class']
+        self.confidence = annotation['confidence']
+        self.bbox = annotation['box']
+        self.segments = annotation['segments'] if 'segments' in annotation else None
+        #Annotation contains name, class, confidence, bbox and segments
+        self.image = image
+    
+    def set_id(self, id):
+        self.id = id
+
+    def fix_empty_segments(self,x_coords,y_coords):
+        self.segments = {'x': x_coords, 'y': y_coords}
+
+    def segments_to_coco_format(self, segment_dict):
+        coco_segment = []
+        for x, y in zip(segment_dict['x'], segment_dict['y']):
+            coco_segment.append(x)
+            coco_segment.append(y)
+        return [coco_segment]
+
+    def bbox_to_coco_format(self, box):
+        x = box['x1']
+        y = box['y1']
+        width = box['x2'] - box['x1']
+        height = box['y2'] - box['y1']
+        return [x, y, width, height]
+
+    def polygon_area(self, segment_dict):
+        #Showlace formula for area of polygon
+        x = segment_dict['x']
+        y = segment_dict['y']
+        return 0.5 * np.abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
+
+    def unify_names(self):
+        self.name = catmus_zones_mapping.get(self.name, self.name)
+
+    def to_coco_format(self, current_annotation_id):
+        cls_string = catmus_zones_mapping.get(self.name, self.name)
+        cls_int = coco_class_mapping[cls_string]
+
+        if self.segments:
+            segmentation = self.segments_to_coco_format(self.segments)
+            area = self.polygon_area(self.segments)
+
+        else:
+            segmentation = []
+            width = self.bbox['x2'] - self.bbox['x1']
+            height = self.bbox['y2'] - self.bbox['y1']
+            area = width * height
+        
+        annotation_dict = {
+            "id": current_annotation_id,
+            "image_id": self.image.id,
+            "category_id": cls_int,
+            "segmentation": segmentation,
+            "area": area,
+            "bbox": self.bbox_to_coco_format(self.bbox),
+            "iscrowd": 0,
+            "attributes": {"occluded": False}
+        }
+        return annotation_dict
+    
+
+class Image:
+    def __init__(self, image_path, image_id):
+        self.path = image_path
+        self.id = image_id
+        self.filename = os.path.basename(image_path)
+        self.width, self.height = self._get_image_dimensions()
+        self.annotations = []
+        self.spatial_index = index.Index()
+        self.deleted_indices = []
+        self.annotations_dict = {}
+
+    def _get_image_dimensions(self):
+        with PILImage.open(self.path) as img:
+            return img.size
+        
+
+    def process_intersection(self, new_box, relevant_classes, overlap_threshold, percentage_dividend, index_to_remove=-1):
+        """
+        Processes intersection of a new bounding box with existing bounding boxes in the spatial index.
+
+        :param new_box: The new bounding box to check for intersections.
+        :param relevant_classes: List of relevant classes to consider for processing.
+        :param overlap_threshold: Minimum overlap percentage threshold to consider an intersection.
+        :param percentage_dividend: Criterion for calculating percentage overlap ('new_box', 'match_bbox', 'symmetric').
+        :param index_to_remove: Index to remove from self.deleted_indices; if -1, remove the intersecting box.
+        """
+        # Find possible matches using spatial index
+        possible_matches = self.spatial_index.intersection(new_box.bounds, objects=True)
+
+        # Iterate over possible matches
+        for match in possible_matches:
+            # Filter matches based on relevant classes
+            if match.object['class'] not in relevant_classes:
+                continue
+
+            # Create bounding box for the matched object
+            match_bbox = box(*match.bbox)
+
+            # Calculate the intersection area
+            intersection_area = new_box.intersection(match_bbox).area
+
+            # Calculate percentage intersection based on the specified dividend
+            if percentage_dividend == 'new_box':
+                percentage_intersection = intersection_area / new_box.area
+            elif percentage_dividend == 'match_bbox':
+                percentage_intersection = intersection_area / match_bbox.area
+            elif percentage_dividend == 'symmetric':
+                # Ensure that both percentages meet the threshold
+                percentage_intersection = min(intersection_area / new_box.area, intersection_area / match_bbox.area)
+            else:
+                raise ValueError("Invalid percentage_dividend value. Must be 'new_box', 'match_bbox', or 'symmetric'.")
+
+            # Append to deleted indices if conditions are met and avoid duplicates
+            if percentage_intersection > overlap_threshold:
+                to_remove = index_to_remove if index_to_remove != -1 else match.id
+                if to_remove not in self.deleted_indices:
+                    self.deleted_indices.append(to_remove)
+
+
+    def process_defaultline(self,new_box,index):
+        
+        possible_matches = list(self.spatial_index.intersection(new_box.bounds, objects=True))
+        #Remove default line if it intersects with any of the following
+        variant_colored_matches = [match for match in possible_matches if match.object['class'] in ['Variant script coloured',
+        'Variant script black','Main script coloured','NumberingZone','Diagram','MarginTextZone','RunningTitleZone','Table',
+        'Quire Mark']]
+
+        if variant_colored_matches:
+            self.deleted_indices.append(index)
+        else:
+            for match in possible_matches:      
+                #Remove Main Script Black if its area overlaps with the default line
+                if match.object['class']=='Main script black':
+                    match_bbox= box(*match.bbox)
+                    intersection_area = new_box.intersection(match_bbox).area
+                    percentage_intersection = (intersection_area / match_bbox.area)
+                    if percentage_intersection > 0.6:
+                        self.deleted_indices.append(match.id)
+        
+    
+    def add_annotation(self, annotation):
+        #Store indices to remove to remove them at the end
+        pos = len(self.annotations)
+        #Correct annotations with segments with empty coordinates
+        minx,miny,maxx,maxy=annotation.bbox['x1'],annotation.bbox['y1'],annotation.bbox['x2'],annotation.bbox['y2']
+        new_box = box(minx,miny,maxx,maxy)
+
+        if annotation.segments: # Execute validations for segmentation models
+
+            if not annotation.segments['x']:
+                x_coords = [minx, minx, maxx, maxx, minx]  
+                y_coords = [miny, maxy, maxy, miny, miny]
+                annotation.fix_empty_segments(x_coords, y_coords)
+
+            if annotation.name in ['Main script black','Main script coloured','Variant script black','Variant script coloured','Plain initial- coloured','Plain initial - Highlighted','Plain initial - Black']:
+                self.process_intersection(new_box,['MarginTextZone','NumberingZone'],0.7,'new_box',pos)
+            
+            if annotation.name in ['Embellished','Plain initial- coloured','Plain initial - Highlighted','Plain initial - Black','Inhabited']:
+                self.process_intersection(new_box,['DropCapitalZone','GraphicZone'],0.4,'symmetric')
+                
+            if annotation.name=='Page Number':
+                self.process_intersection(new_box,['NumberingZone'],0.8,'new_box',pos)
+
+            if annotation.name=='Music':
+                self.process_intersection(new_box,['MusicZone','GraphicZone'],0.7,'new_box')
+
+            if annotation.name=='Table':
+                self.process_intersection(new_box,['MainZone','MarginTextZone'],0.4,'match_bbox')
+
+            if annotation.name in ['Diagram','Illustrations']:
+                self.process_intersection(new_box,['GraphicZone'],0.5,'new_box')
+
+            if annotation.name=='DefaultLine':
+                
+                self.process_defaultline(new_box,pos)
+
+
+        self.annotations.append(annotation)
+        
+        annotation.set_id(pos)
+        self.spatial_index.insert(pos, new_box.bounds,obj={'class':annotation.name})
+
+    def filter_annotations(self):
+    # Convert delete_indices to a set for faster lookup
+        delete_indices_set = set(self.deleted_indices)
+        filtered_annotations = [item for index, item in enumerate(self.annotations) if index not in delete_indices_set]
+        return filtered_annotations
+    
+    def unify_names(self):
+        overlapping_classes = ['MainZone','MarginTextZone']
+        for index, annotation in enumerate(self.annotations):
+            if index not in self.deleted_indices and annotation.name in overlapping_classes:
+                minx,miny,maxx,maxy=annotation.bbox['x1'],annotation.bbox['y1'],annotation.bbox['x2'],annotation.bbox['y2']
+                new_box = box(minx,miny,maxx,maxy)
+
+                possible_matches = self.spatial_index.intersection(new_box.bounds, objects=True)
+
+                for match in possible_matches:
+
+                    if match.id not in self.deleted_indices and match.object['class']==annotation.name and match.id!=index:
+                        match_bbox= box(*match.bbox)
+
+
+                        # Calculate the intersection area as a percentage of the smaller box area
+                        if new_box.area > match_bbox.area:
+                            intersection_area = new_box.intersection(match_bbox).area / match_bbox.area
+                        else:
+                            intersection_area = match_bbox.intersection(new_box).area / new_box.area
+
+                        if intersection_area > 0.80:
+                            delete_index = index if new_box.area < match_bbox.area else match.id
+                            self.deleted_indices.append(delete_index)
+                        
+            annotation.unify_names()
+
+
+
+    
+
+    def to_coco_image_dict(self):
+        return {
+            "id": self.id,
+            "width": self.width,
+            "height": self.height,
+            "file_name": self.filename,
+            "license": 0,
+            "flickr_url": "",
+            "coco_url": "",
+            "date_captured": 0
+        }
+    
+    def plot_annotations(self):
+    # Load the image
+        with PILImage.open(self.path) as img:
+            fig, ax = plt.subplots(1, figsize=(self.width / 100, self.height / 100), dpi=100)
+            ax.imshow(img)
+            
+            for annotation in self.filter_annotations():
+                if annotation.segments:
+                    
+                    # Plot polygon segments
+                    x = annotation.segments['x']
+                    y = annotation.segments['y']
+                    # Close the polygon by appending the first point to the end
+                    x.append(x[0])
+                    y.append(y[0])
+
+                    polygon = patches.Polygon(xy=list(zip(x, y)), closed=True, edgecolor='r', facecolor='none')
+                    ax.add_patch(polygon)
+                    # Annotate the polygon with the name
+                    plt.text(x[0], y[0], annotation.name, color='red', fontsize=25, verticalalignment='top')
+                else:
+                    # Plot bounding box if no segments
+                    bbox = annotation.bbox
+                    x1, y1 = bbox['x1'], bbox['y1']
+                    x2, y2 = bbox['x2'], bbox['y2']
+                    rect = patches.Rectangle(
+                        (x1, y1),
+                        x2 - x1,
+                        y2 - y1,
+                        linewidth=1,
+                        edgecolor='r',
+                        facecolor='none'
+                    )
+                    ax.add_patch(rect)
+                    # Annotate the bounding box with the name
+                    plt.text(x1, y1, annotation.name, color='red', fontsize=25, verticalalignment='top')
+            
+            plt.title(f"Image ID: {self.id} - {self.filename}")
+            plt.axis('off')  # Hide axes
+            plt.show()
+
+
+
+class ImageBatch:
+    def __init__(self, image_folder, catmus_labels_folder, emanuskript_labels_folder,zone_labels_folder):
+        self.image_folder = image_folder
+        self.catmus_labels_folder = catmus_labels_folder
+        self.emanuskript_labels_folder = emanuskript_labels_folder
+        self.zone_labels_folder = zone_labels_folder
+        self.images = []
+
+
+
+    def load_images(self):
+        image_paths = [
+            str(path).replace('\\', '/') 
+            for path in Path(self.image_folder).glob('*') 
+            if path.is_file()  # Ensure only files are processed
+        ]
+        image_paths = sorted(image_paths)
+        
+        for image_id, image_path in enumerate(image_paths, start=1):
+            print(f"Processing image: {image_path}")  # Print the image path
+            self.images.append(Image(image_path, image_id))
+
+
+    def load_annotations(self):
+        for image in self.images:
+            image_basename = os.path.splitext(image.filename)[0]
+
+            catmus_json_path = f'{self.catmus_labels_folder}/{image_basename}.json'
+            emanuskript_json_path = f'{self.emanuskript_labels_folder}/{image_basename}.json'
+            zone_json_path = f'{self.zone_labels_folder}/{image_basename}.json'
+
+            with open(catmus_json_path) as f:
+                catmus_predictions = json.load(f)
+
+            with open(emanuskript_json_path) as f:
+                emanuskripts_predictions = json.load(f)
+
+            with open(zone_json_path) as f:
+                zone_predictions = json.load(f)
+
+            for annotation_data in zone_predictions + emanuskripts_predictions + catmus_predictions :
+                
+                if annotation_data['name'] =='Variant script black' and len(annotation_data['segments']['x'])<3:
+                    pass
+                else:
+                    annotation = Annotation(annotation_data, image)
+                    image.add_annotation(annotation)
+
+    def unify_names(self):
+        for image in self.images:
+            image.unify_names()
+
+    def create_coco_dict(self):
+        coco_dict = {
+            "licenses": [{"name": "", "id": 0, "url": ""}],
+            "info": {
+                "contributor": "",
+                "date_created": "",
+                "description": "",
+                "url": "",
+                "version": "",
+                "year": ""
+            },
+            "categories": [
+                {"id": coco_id, "name": cls_name, "supercategory": ""}
+                for cls_name, coco_id in coco_class_mapping.items()
+            ],
+            "annotations": [annotation.to_coco_format(annotation_id) for image in self.images for annotation_id, annotation in enumerate(image.filter_annotations(), start=1)],
+            "images": [image.to_coco_image_dict() for image in self.images]
+        }
+        return coco_dict
+
+    def save_coco_file(self, output_file):
+        coco_dict = self.create_coco_dict()
+        with open(output_file, 'w') as f:
+            json.dump(coco_dict, f, indent=4)
+
+    def return_coco_file(self):
+        coco_dict = self.create_coco_dict()
+        return coco_dict