Add test_combined_models.py and compare/ folder (excluding cvat_project_7_export and Annika 2 folders)

.gitignore

@@ -33,3 +33,15 @@ __pycache__/
 # OS files
 .DS_Store
 ._*
+
+# Image files (binary files not allowed in HF Spaces)
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.bmp
+*.tiff
+
+# Excel files (binary)
+*.xlsx
+*.xls

compare/data/README.md

@@ -0,0 +1,63 @@
+# Model Comparison Scripts
+
+This directory contains scripts to compare old models vs new models vs ground truth annotations.
+
+## Files
+
+- `original_annotations.py`: Parses CVAT XML annotations and converts to COCO format
+- `old_models.py`: Runs old models (Line, Border, Zones) and converts predictions to COCO
+- `new_models.py`: Runs new models (emanuskript, catmus, zone) and converts predictions to COCO
+- `compare.py`: Main script that orchestrates the comparison and calculates metrics
+
+## Setup
+
+1. Install required dependencies:
+```bash
+pip install pycocotools numpy pillow matplotlib ultralytics
+```
+
+2. Ensure model files are in the project root:
+   - Old models: `best_line_detection_yoloe (1).pt`, `border_model_weights.pt`, `zones_model_weights.pt`
+   - New models: `best_emanuskript_segmentation.pt`, `best_catmus.pt`, `best_zone_detection.pt`
+
+## Usage
+
+Run the main comparison script:
+
+```bash
+cd /home/hasan/layout/compare/data
+python compare.py
+```
+
+The script will:
+1. Load ground truth annotations from `Aleyna 1 (2024)/Annotations/annotations.xml`
+2. Run old models on all images in `Aleyna 1 (2024)/Images`
+3. Run new models on all images
+4. Calculate metrics (mAP@50, mAP@[.50:.95], Precision, Recall)
+5. Create side-by-side visualizations for each image
+
+## Output
+
+Results are saved to `results/` directory:
+- `ground_truth.json`: Ground truth in COCO format
+- `old_models_merged.json`: Old models predictions
+- `new_models_merged.json`: New models predictions
+- `metrics.json`: Calculated metrics for both model sets
+- `visualizations/`: Side-by-side comparison images
+
+## Metrics
+
+The comparison calculates:
+- **mAP@50**: Mean Average Precision at IoU=0.50
+- **mAP@[.50:.95]**: Mean Average Precision averaged over IoU thresholds from 0.50 to 0.95
+- **Precision**: Approximated from mAP@50
+- **Recall**: Maximum recall with 100 detections
+- **F1 Score**: Harmonic mean of Precision and Recall
+
+## Notes
+
+- The CVAT XML parser handles RLE (Run-Length Encoding) format masks
+- Category alignment is performed automatically to match ground truth categories
+- Images are processed sequentially - batch processing may take time
+- Visualizations show: Original+GT | Old Models | New Models side-by-side
+

compare/data/batch_model_comparison_all_datasets.py

@@ -0,0 +1,273 @@
+"""
+Batch model comparison for all expert-annotated datasets.
+
+Datasets:
+- Aleyna 1 (2024)
+- Annika 2 (2024)
+- Luise 1 (2024)
+- Luise 2 (2024)
+- Nuray 1 (2024)
+- Nuray 2 (2024)
+
+For each folder (e.g. "Aleyna 1 (2024)"):
+- Uses the existing `ground_truth_coco.json`
+- Runs OLD models and NEW models on all images in `Images/`
+- Calculates detection/segmentation metrics vs ground truth
+- Creates side‑by‑side visualizations:
+    Ground Truth | Old Models | New Models
+- Saves everything under `<folder>/model_comparison/`
+"""
+import os
+import sys
+import json
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+
+# Paths
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(os.path.dirname(SCRIPT_DIR))
+sys.path.insert(0, SCRIPT_DIR)
+sys.path.insert(0, PROJECT_ROOT)
+
+from old_models import process_dataset as process_old_models
+from new_models import process_dataset as process_new_models
+from compare import calculate_metrics, align_categories, draw_coco_annotations_simple
+
+# Re‑use the same dataset list as in batch_process_all_datasets.py
+DATASET_FOLDERS = [
+    "Aleyna 1 (2024)",
+    "Annika 2 (2024)",
+    "Luise 1 (2024)",
+    "Luise 2 (2024)",
+    "Nuray 1 (2024)",
+    "Nuray 2 (2024)",
+]
+
+
+def create_side_by_side_visualization(image_path, gt_coco, old_coco, new_coco, output_path):
+    """
+    Create side‑by‑side visualization: GT | Old Models | New Models
+    """
+    fig, axes = plt.subplots(1, 3, figsize=(30, 10))
+
+    # Left: Ground Truth
+    draw_coco_annotations_simple(image_path, gt_coco, "Ground Truth", axes[0])
+
+    # Middle: Old Models
+    draw_coco_annotations_simple(image_path, old_coco, "Old Models", axes[1])
+
+    # Right: New Models
+    draw_coco_annotations_simple(image_path, new_coco, "New Models", axes[2])
+
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close()
+    print(f"  ✓ Saved comparison to: {output_path}")
+
+
+def process_expert_dataset(folder_name, base_dir=None):
+    """
+    Process a single expert dataset:
+    - Load ground_truth_coco.json
+    - Run old & new models
+    - Compute metrics
+    - Create GT | Old | New visualizations
+    """
+    if base_dir is None:
+        base_dir = SCRIPT_DIR
+
+    folder_path = Path(base_dir) / folder_name
+
+    if not folder_path.exists():
+        print(f"⚠️  Warning: Folder not found: {folder_path}")
+        return None
+
+    print("\n" + "=" * 70)
+    print(f"Processing expert dataset: {folder_name}")
+    print("=" * 70)
+
+    # Paths
+    gt_json_path = folder_path / "ground_truth_coco.json"
+    images_dir = folder_path / "Images"
+    output_dir = folder_path / "model_comparison"
+    os.makedirs(output_dir, exist_ok=True)
+
+    if not gt_json_path.exists():
+        print(f"❌ Error: ground_truth_coco.json not found at {gt_json_path}")
+        return None
+
+    if not images_dir.exists():
+        print(f"❌ Error: Images directory not found at {images_dir}")
+        return None
+
+    # Load ground truth
+    print(f"\n[1/5] Loading ground truth...")
+    with open(gt_json_path, "r") as f:
+        gt_coco = json.load(f)
+
+    print(f"  ✓ Loaded {len(gt_coco['images'])} images")
+    print(f"  ✓ Loaded {len(gt_coco['annotations'])} annotations")
+
+    # Run old models
+    print(f"\n[2/5] Running old models...")
+    old_output_dir = output_dir / "old_models"
+    os.makedirs(old_output_dir, exist_ok=True)
+
+    try:
+        old_coco = process_old_models(str(images_dir), str(old_output_dir))
+        print(f"  ✓ Generated {len(old_coco['annotations'])} annotations")
+        print(f"  ✓ Categories: {[c['name'] for c in old_coco['categories']]}")
+    except Exception as e:
+        print(f"  ❌ Error running old models: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return None
+
+    # Run new models
+    print(f"\n[3/5] Running new models...")
+    new_output_dir = output_dir / "new_models"
+    os.makedirs(new_output_dir, exist_ok=True)
+
+    try:
+        new_coco = process_new_models(str(images_dir), str(new_output_dir))
+        print(f"  ✓ Generated {len(new_coco['annotations'])} annotations")
+    except Exception as e:
+        print(f"  ❌ Error running new models: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return None
+
+    # Calculate metrics
+    print(f"\n[4/5] Calculating metrics...")
+
+    # Align categories with ground truth (by name matching)
+    old_coco_aligned = align_categories(gt_coco.copy(), old_coco.copy())
+    new_coco_aligned = align_categories(gt_coco.copy(), new_coco.copy())
+
+    # Metrics for old models
+    print(f"\n  Old Models Metrics:")
+    old_metrics = calculate_metrics(gt_coco, old_coco_aligned, str(output_dir))
+    print(f"    mAP@50: {old_metrics.get('mAP@50', 0):.4f}")
+    print(f"    mAP@[.50:.95]: {old_metrics.get('mAP@[.50:.95]', 0):.4f}")
+    print(f"    Precision: {old_metrics.get('Precision', 0):.4f}")
+    print(f"    Recall: {old_metrics.get('Recall', 0):.4f}")
+
+    # Metrics for new models
+    print(f"\n  New Models Metrics:")
+    new_metrics = calculate_metrics(gt_coco, new_coco_aligned, str(output_dir))
+    print(f"    mAP@50: {new_metrics.get('mAP@50', 0):.4f}")
+    print(f"    mAP@[.50:.95]: {new_metrics.get('mAP@[.50:.95]', 0):.4f}")
+    print(f"    Precision: {new_metrics.get('Precision', 0):.4f}")
+    print(f"    Recall: {new_metrics.get('Recall', 0):.4f}")
+
+    # Save metrics JSON
+    metrics_path = output_dir / "metrics.json"
+    with open(metrics_path, "w") as f:
+        json.dump({"old_models": old_metrics, "new_models": new_metrics}, f, indent=4)
+    print(f"  ✓ Saved metrics to: {metrics_path}")
+
+    # Create visualizations
+    print(f"\n[5/5] Creating side-by-side visualizations...")
+    vis_dir = output_dir / "visualizations"
+    os.makedirs(vis_dir, exist_ok=True)
+
+    for img_info in gt_coco["images"]:
+        image_name = img_info["file_name"]
+        image_path = images_dir / image_name
+
+        if not image_path.exists():
+            continue
+
+        img_id = img_info["id"]
+
+        # Filter annotations for this image
+        gt_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in gt_coco["annotations"] if a["image_id"] == img_id],
+            "categories": gt_coco["categories"],
+        }
+
+        old_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in old_coco["annotations"] if a["image_id"] == img_id],
+            "categories": old_coco["categories"],
+        }
+
+        new_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in new_coco["annotations"] if a["image_id"] == img_id],
+            "categories": new_coco["categories"],
+        }
+
+        out_path = vis_dir / f"{Path(image_name).stem}_comparison.png"
+        create_side_by_side_visualization(
+            str(image_path),
+            gt_img_coco,
+            old_img_coco,
+            new_img_coco,
+            str(out_path),
+        )
+
+    print(f"  ✓ Visualizations saved to: {vis_dir}")
+
+    return {
+        "folder": folder_name,
+        "old_metrics": old_metrics,
+        "new_metrics": new_metrics,
+        "old_annotations": len(old_coco["annotations"]),
+        "new_annotations": len(new_coco["annotations"]),
+        "gt_annotations": len(gt_coco["annotations"]),
+    }
+
+
+def main():
+    """Run model comparison for all expert datasets."""
+    print("=" * 70)
+    print("MODEL COMPARISON ON EXPERT DATASETS")
+    print("=" * 70)
+    print(f"\nProcessing {len(DATASET_FOLDERS)} folders:")
+    for folder in DATASET_FOLDERS:
+        print(f"  - {folder}")
+
+    results = []
+
+    for folder_name in DATASET_FOLDERS:
+        result = process_expert_dataset(folder_name)
+        if result:
+            results.append(result)
+
+    # Print summary
+    print("\n" + "=" * 70)
+    print("SUMMARY")
+    print("=" * 70)
+
+    for r in results:
+        print(f"\n{r['folder']}:")
+        print(f"  Ground Truth: {r['gt_annotations']} annotations")
+        print(f"  Old Models: {r['old_annotations']} annotations")
+        print(f"    mAP@50: {r['old_metrics'].get('mAP@50', 0):.4f}")
+        print(f"    Precision: {r['old_metrics'].get('Precision', 0):.4f}")
+        print(f"    Recall: {r['old_metrics'].get('Recall', 0):.4f}")
+        print(f"  New Models: {r['new_annotations']} annotations")
+        print(f"    mAP@50: {r['new_metrics'].get('mAP@50', 0):.4f}")
+        print(f"    Precision: {r['new_metrics'].get('Precision', 0):.4f}")
+        print(f"    Recall: {r['new_metrics'].get('Recall', 0):.4f}")
+
+    # Save summary
+    summary_path = Path(SCRIPT_DIR) / "expert_datasets_model_comparison_summary.json"
+    with open(summary_path, "w") as f:
+        json.dump(results, f, indent=4)
+
+    print(f"\n✓ Summary saved to: {summary_path}")
+    print("\n" + "=" * 70)
+    print("COMPLETE!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()
+
+

compare/data/batch_model_comparison_cvat_export.py

@@ -0,0 +1,291 @@
+"""
+Batch model comparison for CVAT export datasets.
+
+For each task folder (e.g. "task_74_EMS_T1"):
+- Uses `annotations/instances_default.json` as ground truth
+- Runs OLD models and NEW models on all images in `images/`
+- Calculates detection/segmentation metrics vs ground truth
+- Creates side‑by‑side visualizations:
+    Ground Truth | Old Models | New Models
+- Saves everything under `<task_folder>/model_comparison/`
+"""
+import os
+import sys
+import json
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+
+# Paths
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(os.path.dirname(SCRIPT_DIR))
+sys.path.insert(0, SCRIPT_DIR)
+sys.path.insert(0, PROJECT_ROOT)
+
+from old_models import process_dataset as process_old_models
+from new_models import process_dataset as process_new_models
+from compare import calculate_metrics, align_categories, draw_coco_annotations_simple
+
+# CVAT export directory
+CVAT_EXPORT_DIR = Path("/home/hasan/layout/compare/data/cvat_project_7_export")
+
+
+def discover_task_folders(base_dir):
+    """
+    Discover all task folders in the CVAT export directory.
+    A task folder is identified by having:
+    - annotations/instances_default.json
+    - images/ directory
+    """
+    task_folders = []
+    base_path = Path(base_dir)
+    
+    if not base_path.exists():
+        print(f"❌ Error: CVAT export directory not found: {base_path}")
+        return []
+    
+    for item in base_path.iterdir():
+        if item.is_dir():
+            annotations_path = item / "annotations" / "instances_default.json"
+            images_path = item / "images"
+            
+            if annotations_path.exists() and images_path.exists():
+                task_folders.append(item.name)
+    
+    return sorted(task_folders)
+
+
+def create_side_by_side_visualization(image_path, gt_coco, old_coco, new_coco, output_path):
+    """
+    Create side‑by‑side visualization: GT | Old Models | New Models
+    """
+    fig, axes = plt.subplots(1, 3, figsize=(30, 10))
+
+    # Left: Ground Truth
+    draw_coco_annotations_simple(image_path, gt_coco, "Ground Truth", axes[0])
+
+    # Middle: Old Models
+    draw_coco_annotations_simple(image_path, old_coco, "Old Models", axes[1])
+
+    # Right: New Models
+    draw_coco_annotations_simple(image_path, new_coco, "New Models", axes[2])
+
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close()
+    print(f"  ✓ Saved comparison to: {output_path}")
+
+
+def process_cvat_task(task_folder_name, base_dir=None):
+    """
+    Process a single CVAT task folder:
+    - Load annotations/instances_default.json
+    - Run old & new models
+    - Compute metrics
+    - Create GT | Old | New visualizations
+    """
+    if base_dir is None:
+        base_dir = CVAT_EXPORT_DIR
+
+    task_path = Path(base_dir) / task_folder_name
+
+    if not task_path.exists():
+        print(f"⚠️  Warning: Task folder not found: {task_path}")
+        return None
+
+    print("\n" + "=" * 70)
+    print(f"Processing CVAT task: {task_folder_name}")
+    print("=" * 70)
+
+    # Paths
+    gt_json_path = task_path / "annotations" / "instances_default.json"
+    images_dir = task_path / "images"
+    output_dir = task_path / "model_comparison"
+    os.makedirs(output_dir, exist_ok=True)
+
+    if not gt_json_path.exists():
+        print(f"❌ Error: instances_default.json not found at {gt_json_path}")
+        return None
+
+    if not images_dir.exists():
+        print(f"❌ Error: images directory not found at {images_dir}")
+        return None
+
+    # Load ground truth
+    print(f"\n[1/5] Loading ground truth...")
+    with open(gt_json_path, "r") as f:
+        gt_coco = json.load(f)
+
+    print(f"  ✓ Loaded {len(gt_coco['images'])} images")
+    print(f"  ✓ Loaded {len(gt_coco['annotations'])} annotations")
+
+    # Run old models
+    print(f"\n[2/5] Running old models...")
+    old_output_dir = output_dir / "old_models"
+    os.makedirs(old_output_dir, exist_ok=True)
+
+    try:
+        old_coco = process_old_models(str(images_dir), str(old_output_dir))
+        print(f"  ✓ Generated {len(old_coco['annotations'])} annotations")
+        print(f"  ✓ Categories: {[c['name'] for c in old_coco['categories']]}")
+    except Exception as e:
+        print(f"  ❌ Error running old models: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return None
+
+    # Run new models
+    print(f"\n[3/5] Running new models...")
+    new_output_dir = output_dir / "new_models"
+    os.makedirs(new_output_dir, exist_ok=True)
+
+    try:
+        new_coco = process_new_models(str(images_dir), str(new_output_dir))
+        print(f"  ✓ Generated {len(new_coco['annotations'])} annotations")
+    except Exception as e:
+        print(f"  ❌ Error running new models: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return None
+
+    # Calculate metrics
+    print(f"\n[4/5] Calculating metrics...")
+
+    # Align categories with ground truth (by name matching)
+    old_coco_aligned = align_categories(gt_coco.copy(), old_coco.copy())
+    new_coco_aligned = align_categories(gt_coco.copy(), new_coco.copy())
+
+    # Metrics for old models
+    print(f"\n  Old Models Metrics:")
+    old_metrics = calculate_metrics(gt_coco, old_coco_aligned, str(output_dir))
+    print(f"    mAP@50: {old_metrics.get('mAP@50', 0):.4f}")
+    print(f"    mAP@[.50:.95]: {old_metrics.get('mAP@[.50:.95]', 0):.4f}")
+    print(f"    Precision: {old_metrics.get('Precision', 0):.4f}")
+    print(f"    Recall: {old_metrics.get('Recall', 0):.4f}")
+
+    # Metrics for new models
+    print(f"\n  New Models Metrics:")
+    new_metrics = calculate_metrics(gt_coco, new_coco_aligned, str(output_dir))
+    print(f"    mAP@50: {new_metrics.get('mAP@50', 0):.4f}")
+    print(f"    mAP@[.50:.95]: {new_metrics.get('mAP@[.50:.95]', 0):.4f}")
+    print(f"    Precision: {new_metrics.get('Precision', 0):.4f}")
+    print(f"    Recall: {new_metrics.get('Recall', 0):.4f}")
+
+    # Save metrics JSON
+    metrics_path = output_dir / "metrics.json"
+    with open(metrics_path, "w") as f:
+        json.dump({"old_models": old_metrics, "new_models": new_metrics}, f, indent=4)
+    print(f"  ✓ Saved metrics to: {metrics_path}")
+
+    # Create visualizations
+    print(f"\n[5/5] Creating side-by-side visualizations...")
+    vis_dir = output_dir / "visualizations"
+    os.makedirs(vis_dir, exist_ok=True)
+
+    for img_info in gt_coco["images"]:
+        image_name = img_info["file_name"]
+        image_path = images_dir / image_name
+
+        if not image_path.exists():
+            continue
+
+        img_id = img_info["id"]
+
+        # Filter annotations for this image
+        gt_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in gt_coco["annotations"] if a["image_id"] == img_id],
+            "categories": gt_coco["categories"],
+        }
+
+        old_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in old_coco["annotations"] if a["image_id"] == img_id],
+            "categories": old_coco["categories"],
+        }
+
+        new_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in new_coco["annotations"] if a["image_id"] == img_id],
+            "categories": new_coco["categories"],
+        }
+
+        out_path = vis_dir / f"{Path(image_name).stem}_comparison.png"
+        create_side_by_side_visualization(
+            str(image_path),
+            gt_img_coco,
+            old_img_coco,
+            new_img_coco,
+            str(out_path),
+        )
+
+    print(f"  ✓ Visualizations saved to: {vis_dir}")
+
+    return {
+        "task": task_folder_name,
+        "old_metrics": old_metrics,
+        "new_metrics": new_metrics,
+        "old_annotations": len(old_coco["annotations"]),
+        "new_annotations": len(new_coco["annotations"]),
+        "gt_annotations": len(gt_coco["annotations"]),
+    }
+
+
+def main():
+    """Run model comparison for all CVAT export tasks."""
+    print("=" * 70)
+    print("MODEL COMPARISON ON CVAT EXPORT DATASETS")
+    print("=" * 70)
+    
+    # Discover all task folders
+    print(f"\nDiscovering task folders in: {CVAT_EXPORT_DIR}")
+    task_folders = discover_task_folders(CVAT_EXPORT_DIR)
+    
+    if not task_folders:
+        print("❌ No task folders found!")
+        return
+    
+    print(f"\nFound {len(task_folders)} task folders:")
+    for folder in task_folders:
+        print(f"  - {folder}")
+
+    results = []
+
+    for task_folder_name in task_folders:
+        result = process_cvat_task(task_folder_name)
+        if result:
+            results.append(result)
+
+    # Print summary
+    print("\n" + "=" * 70)
+    print("SUMMARY")
+    print("=" * 70)
+
+    for r in results:
+        print(f"\n{r['task']}:")
+        print(f"  Ground Truth: {r['gt_annotations']} annotations")
+        print(f"  Old Models: {r['old_annotations']} annotations")
+        print(f"    mAP@50: {r['old_metrics'].get('mAP@50', 0):.4f}")
+        print(f"    Precision: {r['old_metrics'].get('Precision', 0):.4f}")
+        print(f"    Recall: {r['old_metrics'].get('Recall', 0):.4f}")
+        print(f"  New Models: {r['new_annotations']} annotations")
+        print(f"    mAP@50: {r['new_metrics'].get('mAP@50', 0):.4f}")
+        print(f"    Precision: {r['new_metrics'].get('Precision', 0):.4f}")
+        print(f"    Recall: {r['new_metrics'].get('Recall', 0):.4f}")
+
+    # Save summary
+    summary_path = Path(SCRIPT_DIR) / "cvat_export_model_comparison_summary.json"
+    with open(summary_path, "w") as f:
+        json.dump(results, f, indent=4)
+
+    print(f"\n✓ Summary saved to: {summary_path}")
+    print("\n" + "=" * 70)
+    print("COMPLETE!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()
+

compare/data/batch_model_comparison_test_2025.py

@@ -0,0 +1,273 @@
+"""
+Batch model comparison for all expert-annotated datasets.
+
+Datasets:
+- Aleyna 1 (2024)
+- Annika 2 (2024)
+- Luise 1 (2024)
+- Luise 2 (2024)
+- Nuray 1 (2024)
+- Nuray 2 (2024)
+
+For each folder (e.g. "Aleyna 1 (2024)"):
+- Uses the existing `ground_truth_coco.json`
+- Runs OLD models and NEW models on all images in `Images/`
+- Calculates detection/segmentation metrics vs ground truth
+- Creates side‑by‑side visualizations:
+    Ground Truth | Old Models | New Models
+- Saves everything under `<folder>/model_comparison/`
+"""
+import os
+import sys
+import json
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+
+# Paths
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(os.path.dirname(SCRIPT_DIR))
+sys.path.insert(0, SCRIPT_DIR)
+sys.path.insert(0, PROJECT_ROOT)
+
+from old_models import process_dataset as process_old_models
+from new_models import process_dataset as process_new_models
+from compare import calculate_metrics, align_categories, draw_coco_annotations_simple
+
+# Re‑use the same dataset list as in batch_process_all_datasets.py
+DATASET_FOLDERS = [
+    "Aleyna 1 (2024)",
+    "Annika 2 (2024)",
+    "Luise 1 (2024)",
+    "Luise 2 (2024)",
+    "Nuray 1 (2024)",
+    "Nuray 2 (2024)",
+]
+
+
+def create_side_by_side_visualization(image_path, gt_coco, old_coco, new_coco, output_path):
+    """
+    Create side‑by‑side visualization: GT | Old Models | New Models
+    """
+    fig, axes = plt.subplots(1, 3, figsize=(30, 10))
+
+    # Left: Ground Truth
+    draw_coco_annotations_simple(image_path, gt_coco, "Ground Truth", axes[0])
+
+    # Middle: Old Models
+    draw_coco_annotations_simple(image_path, old_coco, "Old Models", axes[1])
+
+    # Right: New Models
+    draw_coco_annotations_simple(image_path, new_coco, "New Models", axes[2])
+
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=150, bbox_inches="tight")
+    plt.close()
+    print(f"  ✓ Saved comparison to: {output_path}")
+
+
+def process_expert_dataset(folder_name, base_dir=None):
+    """
+    Process a single expert dataset:
+    - Load ground_truth_coco.json
+    - Run old & new models
+    - Compute metrics
+    - Create GT | Old | New visualizations
+    """
+    if base_dir is None:
+        base_dir = SCRIPT_DIR
+
+    folder_path = Path(base_dir) / folder_name
+
+    if not folder_path.exists():
+        print(f"⚠️  Warning: Folder not found: {folder_path}")
+        return None
+
+    print("\n" + "=" * 70)
+    print(f"Processing expert dataset: {folder_name}")
+    print("=" * 70)
+
+    # Paths
+    gt_json_path = folder_path / "ground_truth_coco.json"
+    images_dir = folder_path / "Images"
+    output_dir = folder_path / "model_comparison"
+    os.makedirs(output_dir, exist_ok=True)
+
+    if not gt_json_path.exists():
+        print(f"❌ Error: ground_truth_coco.json not found at {gt_json_path}")
+        return None
+
+    if not images_dir.exists():
+        print(f"❌ Error: Images directory not found at {images_dir}")
+        return None
+
+    # Load ground truth
+    print(f"\n[1/5] Loading ground truth...")
+    with open(gt_json_path, "r") as f:
+        gt_coco = json.load(f)
+
+    print(f"  ✓ Loaded {len(gt_coco['images'])} images")
+    print(f"  ✓ Loaded {len(gt_coco['annotations'])} annotations")
+
+    # Run old models
+    print(f"\n[2/5] Running old models...")
+    old_output_dir = output_dir / "old_models"
+    os.makedirs(old_output_dir, exist_ok=True)
+
+    try:
+        old_coco = process_old_models(str(images_dir), str(old_output_dir))
+        print(f"  ✓ Generated {len(old_coco['annotations'])} annotations")
+        print(f"  ✓ Categories: {[c['name'] for c in old_coco['categories']]}")
+    except Exception as e:
+        print(f"  ❌ Error running old models: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return None
+
+    # Run new models
+    print(f"\n[3/5] Running new models...")
+    new_output_dir = output_dir / "new_models"
+    os.makedirs(new_output_dir, exist_ok=True)
+
+    try:
+        new_coco = process_new_models(str(images_dir), str(new_output_dir))
+        print(f"  ✓ Generated {len(new_coco['annotations'])} annotations")
+    except Exception as e:
+        print(f"  ❌ Error running new models: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return None
+
+    # Calculate metrics
+    print(f"\n[4/5] Calculating metrics...")
+
+    # Align categories with ground truth (by name matching)
+    old_coco_aligned = align_categories(gt_coco.copy(), old_coco.copy())
+    new_coco_aligned = align_categories(gt_coco.copy(), new_coco.copy())
+
+    # Metrics for old models
+    print(f"\n  Old Models Metrics:")
+    old_metrics = calculate_metrics(gt_coco, old_coco_aligned, str(output_dir))
+    print(f"    mAP@50: {old_metrics.get('mAP@50', 0):.4f}")
+    print(f"    mAP@[.50:.95]: {old_metrics.get('mAP@[.50:.95]', 0):.4f}")
+    print(f"    Precision: {old_metrics.get('Precision', 0):.4f}")
+    print(f"    Recall: {old_metrics.get('Recall', 0):.4f}")
+
+    # Metrics for new models
+    print(f"\n  New Models Metrics:")
+    new_metrics = calculate_metrics(gt_coco, new_coco_aligned, str(output_dir))
+    print(f"    mAP@50: {new_metrics.get('mAP@50', 0):.4f}")
+    print(f"    mAP@[.50:.95]: {new_metrics.get('mAP@[.50:.95]', 0):.4f}")
+    print(f"    Precision: {new_metrics.get('Precision', 0):.4f}")
+    print(f"    Recall: {new_metrics.get('Recall', 0):.4f}")
+
+    # Save metrics JSON
+    metrics_path = output_dir / "metrics.json"
+    with open(metrics_path, "w") as f:
+        json.dump({"old_models": old_metrics, "new_models": new_metrics}, f, indent=4)
+    print(f"  ✓ Saved metrics to: {metrics_path}")
+
+    # Create visualizations
+    print(f"\n[5/5] Creating side-by-side visualizations...")
+    vis_dir = output_dir / "visualizations"
+    os.makedirs(vis_dir, exist_ok=True)
+
+    for img_info in gt_coco["images"]:
+        image_name = img_info["file_name"]
+        image_path = images_dir / image_name
+
+        if not image_path.exists():
+            continue
+
+        img_id = img_info["id"]
+
+        # Filter annotations for this image
+        gt_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in gt_coco["annotations"] if a["image_id"] == img_id],
+            "categories": gt_coco["categories"],
+        }
+
+        old_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in old_coco["annotations"] if a["image_id"] == img_id],
+            "categories": old_coco["categories"],
+        }
+
+        new_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in new_coco["annotations"] if a["image_id"] == img_id],
+            "categories": new_coco["categories"],
+        }
+
+        out_path = vis_dir / f"{Path(image_name).stem}_comparison.png"
+        create_side_by_side_visualization(
+            str(image_path),
+            gt_img_coco,
+            old_img_coco,
+            new_img_coco,
+            str(out_path),
+        )
+
+    print(f"  ✓ Visualizations saved to: {vis_dir}")
+
+    return {
+        "folder": folder_name,
+        "old_metrics": old_metrics,
+        "new_metrics": new_metrics,
+        "old_annotations": len(old_coco["annotations"]),
+        "new_annotations": len(new_coco["annotations"]),
+        "gt_annotations": len(gt_coco["annotations"]),
+    }
+
+
+def main():
+    """Run model comparison for all expert datasets."""
+    print("=" * 70)
+    print("MODEL COMPARISON ON EXPERT DATASETS")
+    print("=" * 70)
+    print(f"\nProcessing {len(DATASET_FOLDERS)} folders:")
+    for folder in DATASET_FOLDERS:
+        print(f"  - {folder}")
+
+    results = []
+
+    for folder_name in DATASET_FOLDERS:
+        result = process_expert_dataset(folder_name)
+        if result:
+            results.append(result)
+
+    # Print summary
+    print("\n" + "=" * 70)
+    print("SUMMARY")
+    print("=" * 70)
+
+    for r in results:
+        print(f"\n{r['folder']}:")
+        print(f"  Ground Truth: {r['gt_annotations']} annotations")
+        print(f"  Old Models: {r['old_annotations']} annotations")
+        print(f"    mAP@50: {r['old_metrics'].get('mAP@50', 0):.4f}")
+        print(f"    Precision: {r['old_metrics'].get('Precision', 0):.4f}")
+        print(f"    Recall: {r['old_metrics'].get('Recall', 0):.4f}")
+        print(f"  New Models: {r['new_annotations']} annotations")
+        print(f"    mAP@50: {r['new_metrics'].get('mAP@50', 0):.4f}")
+        print(f"    Precision: {r['new_metrics'].get('Precision', 0):.4f}")
+        print(f"    Recall: {r['new_metrics'].get('Recall', 0):.4f}")
+
+    # Save summary
+    summary_path = Path(SCRIPT_DIR) / "expert_datasets_model_comparison_summary.json"
+    with open(summary_path, "w") as f:
+        json.dump(results, f, indent=4)
+
+    print(f"\n✓ Summary saved to: {summary_path}")
+    print("\n" + "=" * 70)
+    print("COMPLETE!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()
+
+

compare/data/batch_process_all_datasets.py

@@ -0,0 +1,216 @@
+"""
+Batch process all datasets: Convert XML to COCO and create visualizations.
+
+Processes all folders:
+- Aleyna 1 (2024)
+- Annika 2 (2024)
+- Luise 1 (2024)
+- Luise 2 (2024)
+- Nuray 1 (2024)
+- Nuray 2 (2024)
+
+For each folder:
+1. Converts XML annotations to COCO format
+2. Creates visualizations of annotations on images
+3. Saves outputs inside each folder
+"""
+import os
+import sys
+import json
+from pathlib import Path
+
+# Add current directory to path
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+from original_annotations import load_ground_truth
+from visualize_ground_truth import visualize_all_images
+
+
+# List of all dataset folders to process
+DATASET_FOLDERS = [
+    "Aleyna 1 (2024)",
+    "Annika 2 (2024)",
+    "Luise 1 (2024)",
+    "Luise 2 (2024)",
+    "Nuray 1 (2024)",
+    "Nuray 2 (2024)",
+]
+
+
+def process_dataset(folder_name, base_dir=None):
+    """
+    Process a single dataset folder.
+    
+    Args:
+        folder_name: Name of the dataset folder
+        base_dir: Base directory containing the dataset folders (default: SCRIPT_DIR)
+    
+    Returns:
+        dict with processing results
+    """
+    if base_dir is None:
+        base_dir = SCRIPT_DIR
+    
+    folder_path = Path(base_dir) / folder_name
+    
+    if not folder_path.exists():
+        print(f"⚠️  Warning: Folder not found: {folder_path}")
+        return {
+            "folder": folder_name,
+            "status": "not_found",
+            "images": 0,
+            "annotations": 0
+        }
+    
+    print("\n" + "=" * 70)
+    print(f"Processing: {folder_name}")
+    print("=" * 70)
+    
+    # Paths
+    xml_path = folder_path / "Annotations" / "annotations.xml"
+    images_dir = folder_path / "Images"
+    
+    # Check if required files/directories exist
+    if not xml_path.exists():
+        print(f"⚠️  Warning: XML file not found: {xml_path}")
+        return {
+            "folder": folder_name,
+            "status": "no_xml",
+            "images": 0,
+            "annotations": 0
+        }
+    
+    if not images_dir.exists():
+        print(f"⚠️  Warning: Images directory not found: {images_dir}")
+        return {
+            "folder": folder_name,
+            "status": "no_images",
+            "images": 0,
+            "annotations": 0
+        }
+    
+    # Step 1: Convert XML to COCO
+    print(f"\n[Step 1/2] Converting XML to COCO format...")
+    print(f"  XML: {xml_path}")
+    print(f"  Images: {images_dir}")
+    
+    try:
+        coco_json = load_ground_truth(str(xml_path), str(images_dir))
+        
+        if not coco_json:
+            print(f"❌ Error: Failed to parse XML")
+            return {
+                "folder": folder_name,
+                "status": "parse_error",
+                "images": 0,
+                "annotations": 0
+            }
+        
+        num_images = len(coco_json["images"])
+        num_annotations = len(coco_json["annotations"])
+        
+        print(f"  ✓ Loaded {num_images} images")
+        print(f"  ✓ Loaded {num_annotations} annotations")
+        print(f"  ✓ Categories: {len(coco_json['categories'])}")
+        
+        # Save COCO JSON inside the dataset folder
+        coco_output_path = folder_path / "ground_truth_coco.json"
+        with open(coco_output_path, 'w') as f:
+            json.dump(coco_json, f, indent=4)
+        print(f"  ✓ Saved COCO JSON to: {coco_output_path}")
+        
+    except Exception as e:
+        print(f"❌ Error converting XML to COCO: {e}")
+        import traceback
+        traceback.print_exc()
+        return {
+            "folder": folder_name,
+            "status": "conversion_error",
+            "error": str(e),
+            "images": 0,
+            "annotations": 0
+        }
+    
+    # Step 2: Create visualizations
+    print(f"\n[Step 2/2] Creating visualizations...")
+    
+    try:
+        # Create visualizations directory inside the dataset folder
+        vis_output_dir = folder_path / "visualizations"
+        
+        visualize_all_images(coco_json, str(images_dir), str(vis_output_dir))
+        
+        print(f"  ✓ Visualizations saved to: {vis_output_dir}")
+        
+    except Exception as e:
+        print(f"⚠️  Warning: Error creating visualizations: {e}")
+        import traceback
+        traceback.print_exc()
+        # Don't fail the whole process if visualization fails
+    
+    return {
+        "folder": folder_name,
+        "status": "success",
+        "images": num_images,
+        "annotations": num_annotations,
+        "categories": len(coco_json["categories"]),
+        "coco_json_path": str(coco_output_path),
+        "visualizations_path": str(vis_output_dir)
+    }
+
+
+def main():
+    """Main function to process all datasets."""
+    print("=" * 70)
+    print("BATCH PROCESSING: XML to COCO Conversion & Visualization")
+    print("=" * 70)
+    print(f"\nProcessing {len(DATASET_FOLDERS)} datasets:")
+    for folder in DATASET_FOLDERS:
+        print(f"  - {folder}")
+    
+    results = []
+    
+    for folder_name in DATASET_FOLDERS:
+        result = process_dataset(folder_name)
+        results.append(result)
+    
+    # Print summary
+    print("\n" + "=" * 70)
+    print("PROCESSING SUMMARY")
+    print("=" * 70)
+    
+    successful = [r for r in results if r["status"] == "success"]
+    failed = [r for r in results if r["status"] != "success"]
+    
+    print(f"\n✓ Successfully processed: {len(successful)}/{len(results)}")
+    for r in successful:
+        print(f"  - {r['folder']}: {r['images']} images, {r['annotations']} annotations")
+    
+    if failed:
+        print(f"\n⚠️  Failed/Skipped: {len(failed)}/{len(results)}")
+        for r in failed:
+            print(f"  - {r['folder']}: {r['status']}")
+    
+    # Save summary to JSON
+    summary_path = Path(SCRIPT_DIR) / "processing_summary.json"
+    with open(summary_path, 'w') as f:
+        json.dump({
+            "total_datasets": len(DATASET_FOLDERS),
+            "successful": len(successful),
+            "failed": len(failed),
+            "results": results
+        }, f, indent=4)
+    
+    print(f"\n✓ Summary saved to: {summary_path}")
+    print("\n" + "=" * 70)
+    print("BATCH PROCESSING COMPLETE!")
+    print("=" * 70)
+    print("\nEach dataset folder now contains:")
+    print("  - ground_truth_coco.json (COCO format annotations)")
+    print("  - visualizations/ (annotated images)")
+
+
+if __name__ == "__main__":
+    main()
+

compare/data/compare.py

@@ -0,0 +1,642 @@
+"""
+Main comparison script: Compare old models vs new models vs ground truth.
+Calculates mAP@50, mAP@[.50:.95], Precision, Recall.
+Creates side-by-side visualization.
+"""
+import os
+import json
+import sys
+from pathlib import Path
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+import matplotlib.colors as mcolors
+try:
+    from pycocotools.coco import COCO
+    from pycocotools.cocoeval import COCOeval
+    HAS_PYCOCOTOOLS = True
+except ImportError:
+    HAS_PYCOCOTOOLS = False
+    print("Warning: pycocotools not available. Metrics calculation will be limited.")
+    COCO = None
+    COCOeval = None
+
+import tempfile
+
+# Add project root to path
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(os.path.dirname(SCRIPT_DIR))
+sys.path.insert(0, PROJECT_ROOT)
+sys.path.insert(0, SCRIPT_DIR)
+
+from original_annotations import load_ground_truth
+from old_models import process_dataset as process_old_models
+from new_models import process_dataset as process_new_models
+
+
+def draw_coco_annotations_simple(image_path, coco_json, title="", ax=None):
+    """
+    Draw COCO annotations on image (simpler version for comparison).
+    """
+    if ax is None:
+        fig, ax = plt.subplots(1, 1, figsize=(10, 14))
+    
+    img = Image.open(image_path).convert("RGB")
+    ax.imshow(img)
+    ax.set_title(title, fontsize=14, fontweight='bold')
+    ax.axis("off")
+    
+    if not coco_json.get("images"):
+        return ax
+    
+    img_info = coco_json["images"][0]
+    img_id = img_info["id"]
+    anns = [a for a in coco_json["annotations"] if a["image_id"] == img_id]
+    
+    id_to_name = {c["id"]: c["name"] for c in coco_json["categories"]}
+    
+    # Color map
+    colors = plt.cm.tab20(np.linspace(0, 1, 20))
+    color_map = {}
+    
+    # Track label positions to avoid overlap
+    placed_labels = []
+    
+    def find_label_position(bbox, text_width, text_height, image_width, image_height):
+        """Find a good position for label to avoid overlap."""
+        x, y, w, h = bbox
+        candidates = [
+            (x, y - text_height - 5),  # Above top-left
+            (x, y),  # Top-left corner
+            (x + w - text_width, y),  # Top-right corner
+            (x, y + h + 5),  # Below bottom-left
+        ]
+        
+        for pos_x, pos_y in candidates:
+            # Check if position is within image bounds
+            if pos_x < 0 or pos_y < 0 or pos_x + text_width > image_width or pos_y + text_height > image_height:
+                continue
+            
+            # Check overlap with existing labels
+            overlap = False
+            for placed_x, placed_y, placed_w, placed_h in placed_labels:
+                if not (pos_x + text_width < placed_x or pos_x > placed_x + placed_w or
+                        pos_y + text_height < placed_y or pos_y > placed_y + placed_h):
+                    overlap = True
+                    break
+            
+            if not overlap:
+                return pos_x, pos_y
+        
+        # If all positions overlap, use top-left anyway
+        return x, y
+    
+    img_width, img_height = img.size
+    
+    for ann in anns:
+        name = id_to_name.get(ann["category_id"], f"cls_{ann['category_id']}")
+        
+        # Get or assign color
+        if name not in color_map:
+            color_idx = len(color_map) % len(colors)
+            color_map[name] = colors[color_idx]
+        
+        color = color_map[name]
+        
+        # Get bbox for label positioning
+        bbox = ann.get("bbox", [0, 0, 0, 0])
+        if not bbox or len(bbox) < 4:
+            # Try to get bbox from segmentation
+            segs = ann.get("segmentation", [])
+            if segs and isinstance(segs, list) and len(segs) > 0:
+                if isinstance(segs[0], list) and len(segs[0]) >= 6:
+                    coords = segs[0]
+                    xs = coords[0::2]
+                    ys = coords[1::2]
+                    bbox = [min(xs), min(ys), max(xs) - min(xs), max(ys) - min(ys)]
+                else:
+                    continue
+            else:
+                continue
+        
+        x, y, w, h = bbox
+        
+        # Draw segmentation or bbox
+        segs = ann.get("segmentation", [])
+        if segs and isinstance(segs, list) and len(segs) > 0:
+            if isinstance(segs[0], list) and len(segs[0]) >= 6:
+                # Polygon
+                coords = segs[0]
+                xs = coords[0::2]
+                ys = coords[1::2]
+                poly = patches.Polygon(
+                    list(zip(xs, ys)),
+                    closed=True,
+                    edgecolor=color,
+                    facecolor=color,
+                    linewidth=2,
+                    alpha=0.3,
+                )
+                ax.add_patch(poly)
+                # Edge
+                poly_edge = patches.Polygon(
+                    list(zip(xs, ys)),
+                    closed=True,
+                    edgecolor=color,
+                    facecolor="none",
+                    linewidth=2,
+                    alpha=0.8,
+                )
+                ax.add_patch(poly_edge)
+        else:
+            # Bbox
+            rect = patches.Rectangle(
+                (x, y),
+                w,
+                h,
+                edgecolor=color,
+                facecolor=color,
+                linewidth=2,
+                alpha=0.3,
+            )
+            ax.add_patch(rect)
+            # Edge
+            rect_edge = patches.Rectangle(
+                (x, y),
+                w,
+                h,
+                edgecolor=color,
+                facecolor="none",
+                linewidth=2,
+                alpha=0.8,
+            )
+            ax.add_patch(rect_edge)
+        
+        # Add label
+        # Estimate text size (approximate)
+        text_width = len(name) * 7  # Approximate character width
+        text_height = 12  # Approximate text height
+        
+        label_x, label_y = find_label_position(bbox, text_width, text_height, img_width, img_height)
+        placed_labels.append((label_x, label_y, text_width, text_height))
+        
+        # Draw label with background
+        # Convert color to RGB tuple if it's an array
+        if isinstance(color, np.ndarray):
+            edge_color = tuple(color[:3])
+        elif isinstance(color, (list, tuple)) and len(color) >= 3:
+            edge_color = tuple(color[:3])
+        else:
+            edge_color = color
+        
+        ax.text(
+            label_x,
+            label_y,
+            name,
+            color='black',
+            fontsize=9,
+            fontweight='bold',
+            bbox=dict(
+                boxstyle="round,pad=0.3",
+                facecolor="white",
+                edgecolor=edge_color,
+                linewidth=2,
+                alpha=0.9,
+            ),
+            zorder=10,  # Ensure labels are on top
+        )
+    
+    return ax
+
+
+def validate_and_fix_annotation(ann, img_width, img_height):
+    """
+    Validate and fix annotation segmentation/bbox.
+    Converts bbox to polygon if segmentation is missing or invalid.
+    """
+    segs = ann.get("segmentation", [])
+    bbox = ann.get("bbox", [0, 0, 0, 0])
+    
+    # Check if segmentation is valid
+    has_valid_seg = False
+    if segs and isinstance(segs, list) and len(segs) > 0:
+        # Check if it's a polygon (list of coordinates)
+        if isinstance(segs[0], list) and len(segs[0]) >= 6:
+            # Valid polygon
+            has_valid_seg = True
+        # Check if it's RLE (dict)
+        elif isinstance(segs, dict) or (isinstance(segs, list) and len(segs) > 0 and isinstance(segs[0], dict)):
+            # RLE format - assume valid
+            has_valid_seg = True
+    
+    # If no valid segmentation, create polygon from bbox
+    if not has_valid_seg and len(bbox) == 4 and bbox[2] > 0 and bbox[3] > 0:
+        x, y, w, h = bbox
+        # Create polygon from bbox: [x, y, x+w, y, x+w, y+h, x, y+h]
+        polygon = [x, y, x + w, y, x + w, y + h, x, y + h]
+        ann["segmentation"] = [polygon]
+        # Update area if needed
+        if ann.get("area", 0) == 0:
+            ann["area"] = w * h
+        has_valid_seg = True
+    
+    return has_valid_seg
+
+
+def filter_valid_annotations(coco_dict):
+    """
+    Filter out annotations with invalid segmentation/bbox.
+    Convert bbox-only annotations to polygon format.
+    """
+    # Get image dimensions
+    img_id_to_size = {}
+    for img in coco_dict["images"]:
+        img_id_to_size[img["id"]] = (img["width"], img["height"])
+    
+    valid_annotations = []
+    for ann in coco_dict["annotations"]:
+        img_id = ann["image_id"]
+        if img_id in img_id_to_size:
+            img_width, img_height = img_id_to_size[img_id]
+            if validate_and_fix_annotation(ann, img_width, img_height):
+                valid_annotations.append(ann)
+    
+    coco_dict["annotations"] = valid_annotations
+    return coco_dict
+
+
+def calculate_metrics(gt_coco, pred_coco, output_dir):
+    """
+    Calculate mAP@50, mAP@[.50:.95], Precision, Recall using pycocotools.
+    
+    Args:
+        gt_coco: Ground truth COCO format dict
+        pred_coco: Predictions COCO format dict
+        output_dir: Directory to save results
+    
+    Returns:
+        Dictionary with metrics
+    """
+    if not HAS_PYCOCOTOOLS:
+        return {
+            'mAP@50': 0.0,
+            'mAP@[.50:.95]': 0.0,
+            'Precision': 0.0,
+            'Recall': 0.0,
+            'F1': 0.0,
+            'error': 'pycocotools not available'
+        }
+    
+    # Filter and fix invalid annotations
+    gt_coco_clean = filter_valid_annotations(gt_coco.copy())
+    pred_coco_clean = filter_valid_annotations(pred_coco.copy())
+    
+    if len(gt_coco_clean["annotations"]) == 0:
+        print("Warning: No valid ground truth annotations after filtering")
+        return {
+            'mAP@50': 0.0,
+            'mAP@[.50:.95]': 0.0,
+            'Precision': 0.0,
+            'Recall': 0.0,
+            'F1': 0.0,
+            'error': 'No valid GT annotations'
+        }
+    
+    if len(pred_coco_clean["annotations"]) == 0:
+        print("Warning: No valid prediction annotations after filtering")
+        return {
+            'mAP@50': 0.0,
+            'mAP@[.50:.95]': 0.0,
+            'Precision': 0.0,
+            'Recall': 0.0,
+            'F1': 0.0,
+            'error': 'No valid prediction annotations'
+        }
+    
+    # Save to temporary JSON files for pycocotools
+    gt_file = os.path.join(output_dir, "gt_temp.json")
+    pred_file = os.path.join(output_dir, "pred_temp.json")
+    
+    with open(gt_file, 'w') as f:
+        json.dump(gt_coco_clean, f)
+    
+    with open(pred_file, 'w') as f:
+        json.dump(pred_coco_clean, f)
+    
+    # Load with pycocotools
+    try:
+        gt_coco_obj = COCO(gt_file)
+        pred_coco_obj = COCO(pred_file)
+    except Exception as e:
+        print(f"Error loading COCO files: {e}")
+        return {
+            'mAP@50': 0.0,
+            'mAP@[.50:.95]': 0.0,
+            'Precision': 0.0,
+            'Recall': 0.0,
+            'F1': 0.0,
+            'error': f'COCO load error: {str(e)}'
+        }
+    
+    # Get all image IDs
+    img_ids = sorted(gt_coco_obj.getImgIds())
+    
+    if len(img_ids) == 0:
+        return {
+            'mAP@50': 0.0,
+            'mAP@[.50:.95]': 0.0,
+            'Precision': 0.0,
+            'Recall': 0.0,
+            'F1': 0.0,
+            'error': 'No images in GT'
+        }
+    
+    # Get all category IDs from ground truth
+    cat_ids = sorted(gt_coco_obj.getCatIds())
+    
+    # Try segmentation evaluation first, fall back to bbox if it fails
+    eval_type = 'segm'
+    try:
+        coco_eval = COCOeval(gt_coco_obj, pred_coco_obj, eval_type)
+        coco_eval.params.imgIds = img_ids
+        coco_eval.params.catIds = cat_ids
+        coco_eval.evaluate()
+        coco_eval.accumulate()
+        coco_eval.summarize()
+        
+        # Extract metrics
+        metrics = {
+            'mAP@50': float(coco_eval.stats[1]),  # mAP@0.50
+            'mAP@[.50:.95]': float(coco_eval.stats[0]),  # mAP@[.50:.95]
+            'mAP@75': float(coco_eval.stats[2]),  # mAP@0.75
+            'mAP_small': float(coco_eval.stats[3]),
+            'mAP_medium': float(coco_eval.stats[4]),
+            'mAP_large': float(coco_eval.stats[5]),
+            'mAR_1': float(coco_eval.stats[6]),
+            'mAR_10': float(coco_eval.stats[7]),
+            'mAR_100': float(coco_eval.stats[8]),
+            'mAR_small': float(coco_eval.stats[9]),
+            'mAR_medium': float(coco_eval.stats[10]),
+            'mAR_large': float(coco_eval.stats[11]),
+        }
+        
+        # Calculate Precision and Recall
+        precision = metrics['mAP@50']  # Approximate
+        recall = metrics['mAR_100']  # Maximum recall with 100 detections
+        
+        metrics['Precision'] = precision
+        metrics['Recall'] = recall
+        metrics['F1'] = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+        
+    except Exception as e:
+        print(f"Error during {eval_type} evaluation: {e}")
+        # Try bbox evaluation as fallback
+        try:
+            print("Trying bbox evaluation as fallback...")
+            coco_eval = COCOeval(gt_coco_obj, pred_coco_obj, 'bbox')
+            coco_eval.params.imgIds = img_ids
+            coco_eval.params.catIds = cat_ids
+            coco_eval.evaluate()
+            coco_eval.accumulate()
+            coco_eval.summarize()
+            
+            metrics = {
+                'mAP@50': float(coco_eval.stats[1]),
+                'mAP@[.50:.95]': float(coco_eval.stats[0]),
+                'mAP@75': float(coco_eval.stats[2]),
+                'mAP_small': float(coco_eval.stats[3]),
+                'mAP_medium': float(coco_eval.stats[4]),
+                'mAP_large': float(coco_eval.stats[5]),
+                'mAR_1': float(coco_eval.stats[6]),
+                'mAR_10': float(coco_eval.stats[7]),
+                'mAR_100': float(coco_eval.stats[8]),
+                'mAR_small': float(coco_eval.stats[9]),
+                'mAR_medium': float(coco_eval.stats[10]),
+                'mAR_large': float(coco_eval.stats[11]),
+            }
+            
+            precision = metrics['mAP@50']
+            recall = metrics['mAR_100']
+            
+            metrics['Precision'] = precision
+            metrics['Recall'] = recall
+            metrics['F1'] = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+            metrics['eval_type'] = 'bbox'  # Note that we used bbox evaluation
+            
+        except Exception as e2:
+            print(f"Error during bbox evaluation: {e2}")
+            import traceback
+            traceback.print_exc()
+            metrics = {
+                'mAP@50': 0.0,
+                'mAP@[.50:.95]': 0.0,
+                'Precision': 0.0,
+                'Recall': 0.0,
+                'F1': 0.0,
+                'error': f'{eval_type} error: {str(e)}, bbox error: {str(e2)}'
+            }
+    
+    return metrics
+
+
+def create_comparison_visualization(image_path, gt_coco, old_coco, new_coco, output_path):
+    """
+    Create side-by-side comparison: Original + GT | Old Models | New Models
+    """
+    fig, axes = plt.subplots(1, 3, figsize=(30, 10))
+    
+    # Left: Original image with ground truth
+    draw_coco_annotations_simple(image_path, gt_coco, "Ground Truth", axes[0])
+    
+    # Middle: Old models
+    draw_coco_annotations_simple(image_path, old_coco, "Old Models", axes[1])
+    
+    # Right: New models
+    draw_coco_annotations_simple(image_path, new_coco, "New Models", axes[2])
+    
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"Saved comparison visualization to {output_path}")
+
+
+def align_categories(gt_coco, pred_coco):
+    """
+    Align category IDs between GT and predictions.
+    Maps prediction categories to GT categories by name.
+    """
+    # Create name to ID maps
+    gt_name_to_id = {c["name"]: c["id"] for c in gt_coco["categories"]}
+    pred_name_to_id = {c["name"]: c["id"] for c in pred_coco["categories"]}
+    
+    # Create mapping from pred category ID to GT category ID
+    pred_to_gt_map = {}
+    for pred_name, pred_id in pred_name_to_id.items():
+        if pred_name in gt_name_to_id:
+            pred_to_gt_map[pred_id] = gt_name_to_id[pred_name]
+        else:
+            # If category doesn't exist in GT, skip it
+            print(f"Warning: Category '{pred_name}' not in ground truth, skipping...")
+    
+    # Update prediction annotations
+    new_anns = []
+    for ann in pred_coco["annotations"]:
+        old_cat_id = ann["category_id"]
+        if old_cat_id in pred_to_gt_map:
+            new_ann = ann.copy()
+            new_ann["category_id"] = pred_to_gt_map[old_cat_id]
+            new_anns.append(new_ann)
+    
+    pred_coco["annotations"] = new_anns
+    
+    # Update categories to match GT
+    pred_coco["categories"] = [
+        c for c in gt_coco["categories"]
+        if c["name"] in pred_name_to_id
+    ]
+    
+    return pred_coco
+
+
+def main():
+    """
+    Main comparison function.
+    """
+    # Paths
+    data_dir = os.path.join(SCRIPT_DIR, "Aleyna 1 (2024)")
+    xml_path = os.path.join(data_dir, "Annotations", "annotations.xml")
+    images_dir = os.path.join(data_dir, "Images")
+    output_dir = os.path.join(SCRIPT_DIR, "results")
+    
+    os.makedirs(output_dir, exist_ok=True)
+    
+    print("=" * 60)
+    print("COMPARISON: Old Models vs New Models vs Ground Truth")
+    print("=" * 60)
+    
+    # 1. Load ground truth
+    print("\n[1/4] Loading ground truth annotations...")
+    gt_coco = load_ground_truth(xml_path, images_dir)
+    print(f"  ✓ Loaded {len(gt_coco['images'])} images")
+    print(f"  ✓ Loaded {len(gt_coco['annotations'])} annotations")
+    print(f"  ✓ Categories: {[c['name'] for c in gt_coco['categories']]}")
+    
+    # Save GT
+    gt_output = os.path.join(output_dir, "ground_truth.json")
+    with open(gt_output, 'w') as f:
+        json.dump(gt_coco, f, indent=2)
+    print(f"  ✓ Saved to {gt_output}")
+    
+    # 2. Run old models
+    print("\n[2/4] Running old models...")
+    old_output_dir = os.path.join(output_dir, "old_models")
+    os.makedirs(old_output_dir, exist_ok=True)
+    old_coco = process_old_models(images_dir, old_output_dir)
+    print(f"  ✓ Processed {len(old_coco['images'])} images")
+    print(f"  ✓ Generated {len(old_coco['annotations'])} annotations")
+    
+    old_output = os.path.join(output_dir, "old_models_merged.json")
+    with open(old_output, 'w') as f:
+        json.dump(old_coco, f, indent=2)
+    print(f"  ✓ Saved to {old_output}")
+    
+    # 3. Run new models
+    print("\n[3/4] Running new models...")
+    new_output_dir = os.path.join(output_dir, "new_models")
+    os.makedirs(new_output_dir, exist_ok=True)
+    new_coco = process_new_models(images_dir, new_output_dir)
+    print(f"  ✓ Processed {len(new_coco['images'])} images")
+    print(f"  ✓ Generated {len(new_coco['annotations'])} annotations")
+    
+    new_output = os.path.join(output_dir, "new_models_merged.json")
+    with open(new_output, 'w') as f:
+        json.dump(new_coco, f, indent=2)
+    print(f"  ✓ Saved to {new_output}")
+    
+    # 4. Calculate metrics
+    print("\n[4/4] Calculating metrics...")
+    
+    # Align categories
+    old_coco_aligned = align_categories(gt_coco.copy(), old_coco.copy())
+    new_coco_aligned = align_categories(gt_coco.copy(), new_coco.copy())
+    
+    # Calculate metrics for old models
+    print("\n  Calculating metrics for OLD MODELS...")
+    old_metrics = calculate_metrics(gt_coco, old_coco_aligned, output_dir)
+    print(f"    mAP@50: {old_metrics['mAP@50']:.4f}")
+    print(f"    mAP@[.50:.95]: {old_metrics['mAP@[.50:.95]']:.4f}")
+    print(f"    Precision: {old_metrics['Precision']:.4f}")
+    print(f"    Recall: {old_metrics['Recall']:.4f}")
+    
+    # Calculate metrics for new models
+    print("\n  Calculating metrics for NEW MODELS...")
+    new_metrics = calculate_metrics(gt_coco, new_coco_aligned, output_dir)
+    print(f"    mAP@50: {new_metrics['mAP@50']:.4f}")
+    print(f"    mAP@[.50:.95]: {new_metrics['mAP@[.50:.95]']:.4f}")
+    print(f"    Precision: {new_metrics['Precision']:.4f}")
+    print(f"    Recall: {new_metrics['Recall']:.4f}")
+    
+    # Save metrics
+    metrics_output = os.path.join(output_dir, "metrics.json")
+    with open(metrics_output, 'w') as f:
+        json.dump({
+            'old_models': old_metrics,
+            'new_models': new_metrics
+        }, f, indent=2)
+    print(f"\n  ✓ Saved metrics to {metrics_output}")
+    
+    # 5. Create visualizations for each image
+    print("\n[5/5] Creating comparison visualizations...")
+    vis_dir = os.path.join(output_dir, "visualizations")
+    os.makedirs(vis_dir, exist_ok=True)
+    
+    for img_info in gt_coco["images"]:
+        image_name = img_info["file_name"]
+        image_path = os.path.join(images_dir, image_name)
+        
+        if not os.path.exists(image_path):
+            continue
+        
+        # Get COCO for this image
+        img_id = img_info["id"]
+        
+        # Filter annotations for this image
+        gt_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in gt_coco["annotations"] if a["image_id"] == img_id],
+            "categories": gt_coco["categories"]
+        }
+        
+        old_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in old_coco["annotations"] if a["image_id"] == img_id],
+            "categories": old_coco["categories"]
+        }
+        
+        new_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in new_coco["annotations"] if a["image_id"] == img_id],
+            "categories": new_coco["categories"]
+        }
+        
+        # Create visualization
+        output_path = os.path.join(vis_dir, f"{Path(image_name).stem}_comparison.png")
+        create_comparison_visualization(
+            image_path,
+            gt_img_coco,
+            old_img_coco,
+            new_img_coco,
+            output_path
+        )
+    
+    print(f"\n  ✓ Saved visualizations to {vis_dir}")
+    print("\n" + "=" * 60)
+    print("COMPARISON COMPLETE!")
+    print("=" * 60)
+    print(f"\nResults saved to: {output_dir}")
+
+
+if __name__ == "__main__":
+    main()
+

compare/data/expert_datasets_model_comparison_summary.json

@@ -0,0 +1,134 @@
+[
+    {
+        "folder": "Aleyna 1 (2024)",
+        "old_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "No valid prediction annotations"
+        },
+        "new_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "segm error: 'score', bbox error: 'score'"
+        },
+        "old_annotations": 829,
+        "new_annotations": 1127,
+        "gt_annotations": 44
+    },
+    {
+        "folder": "Annika 2 (2024)",
+        "old_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "No valid prediction annotations"
+        },
+        "new_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "segm error: 'score', bbox error: 'score'"
+        },
+        "old_annotations": 769,
+        "new_annotations": 898,
+        "gt_annotations": 136
+    },
+    {
+        "folder": "Luise 1 (2024)",
+        "old_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "No valid GT annotations"
+        },
+        "new_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "No valid GT annotations"
+        },
+        "old_annotations": 415,
+        "new_annotations": 712,
+        "gt_annotations": 0
+    },
+    {
+        "folder": "Luise 2 (2024)",
+        "old_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "No valid prediction annotations"
+        },
+        "new_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "segm error: 'score', bbox error: 'score'"
+        },
+        "old_annotations": 715,
+        "new_annotations": 759,
+        "gt_annotations": 99
+    },
+    {
+        "folder": "Nuray 1 (2024)",
+        "old_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "No valid prediction annotations"
+        },
+        "new_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "segm error: 'score', bbox error: 'score'"
+        },
+        "old_annotations": 301,
+        "new_annotations": 417,
+        "gt_annotations": 64
+    },
+    {
+        "folder": "Nuray 2 (2024)",
+        "old_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "No valid prediction annotations"
+        },
+        "new_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "segm error: 'score', bbox error: 'score'"
+        },
+        "old_annotations": 419,
+        "new_annotations": 467,
+        "gt_annotations": 25
+    }
+]

compare/data/ground_truth_coco.json

@@ -0,0 +1,1217 @@
+{
+    "info": {
+        "description": "Converted from CVAT XML",
+        "year": 2024,
+        "version": "1.0"
+    },
+    "licenses": [],
+    "images": [
+        {
+            "id": 1,
+            "width": 6132,
+            "height": 8176,
+            "file_name": "e-codices_bbb-0219_001v_max.jpg"
+        },
+        {
+            "id": 2,
+            "width": 6132,
+            "height": 8176,
+            "file_name": "e-codices_bbb-0219_003v_max.jpg"
+        },
+        {
+            "id": 3,
+            "width": 6132,
+            "height": 8176,
+            "file_name": "e-codices_bbb-0219_007v_max.jpg"
+        },
+        {
+            "id": 4,
+            "width": 6132,
+            "height": 8176,
+            "file_name": "e-codices_bbb-0219_023v_max.jpg"
+        },
+        {
+            "id": 5,
+            "width": 6132,
+            "height": 8176,
+            "file_name": "e-codices_bbb-0219_041v_max.jpg"
+        },
+        {
+            "id": 6,
+            "width": 6132,
+            "height": 8176,
+            "file_name": "e-codices_bbb-0219_044r_maxr.jpg"
+        },
+        {
+            "id": 7,
+            "width": 6132,
+            "height": 8176,
+            "file_name": "e-codices_bbb-0219_047v_max.jpg"
+        },
+        {
+            "id": 8,
+            "width": 6132,
+            "height": 8176,
+            "file_name": "e-codices_bbb-0219_050v_max.jpg"
+        },
+        {
+            "id": 9,
+            "width": 6132,
+            "height": 8176,
+            "file_name": "e-codices_bbb-0219_055r_max.jpg"
+        },
+        {
+            "id": 10,
+            "width": 6132,
+            "height": 8176,
+            "file_name": "e-codices_bbb-0219_070v_max.jpg"
+        }
+    ],
+    "annotations": [
+        {
+            "id": 1,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                1348,
+                5552,
+                2039,
+                295
+            ],
+            "area": 601505,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 2,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3825,
+                6664,
+                2186,
+                231
+            ],
+            "area": 504966,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 3,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3838,
+                3853,
+                2066,
+                216
+            ],
+            "area": 446256,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 4,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                1113,
+                5968,
+                2270,
+                194
+            ],
+            "area": 440380,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 5,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3721,
+                5186,
+                2300,
+                260
+            ],
+            "area": 598000,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 6,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3809,
+                5978,
+                2058,
+                183
+            ],
+            "area": 376614,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 7,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3809,
+                6891,
+                1949,
+                231
+            ],
+            "area": 450219,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 8,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                1098,
+                6337,
+                1659,
+                269
+            ],
+            "area": 446271,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 9,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3838,
+                5373,
+                2095,
+                277
+            ],
+            "area": 580315,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 10,
+            "image_id": 1,
+            "category_id": 11,
+            "bbox": [
+                3828,
+                1769,
+                1998,
+                379
+            ],
+            "area": 757242,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 11,
+            "image_id": 1,
+            "category_id": 21,
+            "bbox": [
+                595,
+                511,
+                5442,
+                4998
+            ],
+            "area": 27199116,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 12,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3845,
+                4989,
+                2187,
+                248
+            ],
+            "area": 542376,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 13,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3834,
+                3292,
+                2187,
+                246
+            ],
+            "area": 538002,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 14,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                1097,
+                6172,
+                2116,
+                204
+            ],
+            "area": 431664,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 15,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                1082,
+                6516,
+                2311,
+                244
+            ],
+            "area": 563884,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 16,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3853,
+                4227,
+                1941,
+                263
+            ],
+            "area": 510483,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 17,
+            "image_id": 1,
+            "category_id": 4,
+            "bbox": [
+                848,
+                5400,
+                636,
+                594
+            ],
+            "area": 377784,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 18,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                1085,
+                6739,
+                2174,
+                235
+            ],
+            "area": 510890,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 19,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3809,
+                6336,
+                2104,
+                163
+            ],
+            "area": 342952,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 20,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3778,
+                6465,
+                2198,
+                304
+            ],
+            "area": 668192,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 21,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                1470,
+                5751,
+                1944,
+                237
+            ],
+            "area": 460728,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 22,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3838,
+                4036,
+                2132,
+                249
+            ],
+            "area": 530868,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 23,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3820,
+                3640,
+                1985,
+                224
+            ],
+            "area": 444640,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 24,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3816,
+                5743,
+                2183,
+                271
+            ],
+            "area": 591593,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 25,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3853,
+                5567,
+                2080,
+                202
+            ],
+            "area": 420160,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 26,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3831,
+                6139,
+                2165,
+                186
+            ],
+            "area": 402690,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 27,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3772,
+                4824,
+                2205,
+                267
+            ],
+            "area": 588735,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 28,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                1092,
+                7062,
+                1461,
+                237
+            ],
+            "area": 346257,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 29,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3831,
+                3472,
+                2183,
+                234
+            ],
+            "area": 510822,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 30,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                1026,
+                6935,
+                2314,
+                215
+            ],
+            "area": 497510,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 31,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3853,
+                4461,
+                2000,
+                245
+            ],
+            "area": 490000,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 32,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3800,
+                7049,
+                2157,
+                269
+            ],
+            "area": 580233,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 33,
+            "image_id": 1,
+            "category_id": 10,
+            "bbox": [
+                3853,
+                4659,
+                2143,
+                197
+            ],
+            "area": 422171,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 34,
+            "image_id": 2,
+            "category_id": 10,
+            "bbox": [
+                869.8,
+                816.34,
+                2091.09,
+                243.56000000000006
+            ],
+            "area": 250644.53920000035,
+            "iscrowd": 0,
+            "segmentation": [
+                [
+                    869.8,
+                    911.39,
+                    961.88,
+                    863.86,
+                    985.64,
+                    893.56,
+                    1039.11,
+                    828.22,
+                    1095.54,
+                    863.86,
+                    1131.19,
+                    881.68,
+                    1172.77,
+                    869.8,
+                    1226.24,
+                    857.92,
+                    1267.82,
+                    863.86,
+                    1645.05,
+                    863.86,
+                    2170.79,
+                    846.04,
+                    2937.13,
+                    816.34,
+                    2960.89,
+                    917.33,
+                    2747.03,
+                    941.09,
+                    2741.09,
+                    941.09,
+                    2402.48,
+                    964.85,
+                    1936.14,
+                    964.85,
+                    1852.97,
+                    1006.44,
+                    1769.8,
+                    982.67,
+                    1677.72,
+                    967.82,
+                    1505.45,
+                    979.7,
+                    1327.23,
+                    976.73,
+                    1214.36,
+                    988.61,
+                    1119.31,
+                    982.67,
+                    994.55,
+                    997.52,
+                    881.68,
+                    1059.9
+                ]
+            ]
+        },
+        {
+            "id": 35,
+            "image_id": 2,
+            "category_id": 21,
+            "bbox": [
+                556.0,
+                5498.0,
+                2620.0,
+                1290.0
+            ],
+            "area": 2305750.0,
+            "iscrowd": 0,
+            "segmentation": [
+                [
+                    726.0,
+                    5648.0,
+                    626.0,
+                    5718.0,
+                    576.0,
+                    5828.0,
+                    566.0,
+                    5918.0,
+                    556.0,
+                    6018.0,
+                    636.0,
+                    6028.0,
+                    756.0,
+                    5968.0,
+                    796.0,
+                    5908.0,
+                    856.0,
+                    5838.0,
+                    886.0,
+                    5728.0,
+                    866.0,
+                    5918.0,
+                    876.0,
+                    6028.0,
+                    896.0,
+                    6128.0,
+                    896.0,
+                    6228.0,
+                    856.0,
+                    6328.0,
+                    856.0,
+                    6448.0,
+                    866.0,
+                    6508.0,
+                    876.0,
+                    6568.0,
+                    876.0,
+                    6658.0,
+                    876.0,
+                    6728.0,
+                    876.0,
+                    6788.0,
+                    926.0,
+                    6778.0,
+                    976.0,
+                    6748.0,
+                    1026.0,
+                    6708.0,
+                    1116.0,
+                    6648.0,
+                    1156.0,
+                    6608.0,
+                    1196.0,
+                    6588.0,
+                    1236.0,
+                    6568.0,
+                    1296.0,
+                    6558.0,
+                    1326.0,
+                    6548.0,
+                    1326.0,
+                    6548.0,
+                    1376.0,
+                    6568.0,
+                    1416.0,
+                    6568.0,
+                    1486.0,
+                    6558.0,
+                    1536.0,
+                    6558.0,
+                    1586.0,
+                    6568.0,
+                    1676.0,
+                    6568.0,
+                    1836.0,
+                    6558.0,
+                    1916.0,
+                    6568.0,
+                    1976.0,
+                    6568.0,
+                    2056.0,
+                    6568.0,
+                    2136.0,
+                    6568.0,
+                    2206.0,
+                    6568.0,
+                    2326.0,
+                    6558.0,
+                    2396.0,
+                    6558.0,
+                    2476.0,
+                    6548.0,
+                    2536.0,
+                    6548.0,
+                    2606.0,
+                    6548.0,
+                    2676.0,
+                    6538.0,
+                    2756.0,
+                    6538.0,
+                    2856.0,
+                    6528.0,
+                    2936.0,
+                    6528.0,
+                    2996.0,
+                    6518.0,
+                    3066.0,
+                    6508.0,
+                    3066.0,
+                    6508.0,
+                    3066.0,
+                    6498.0,
+                    3066.0,
+                    6498.0,
+                    3076.0,
+                    6438.0,
+                    3046.0,
+                    6388.0,
+                    3026.0,
+                    6358.0,
+                    3016.0,
+                    6308.0,
+                    2996.0,
+                    6248.0,
+                    2956.0,
+                    6208.0,
+                    2936.0,
+                    6158.0,
+                    2926.0,
+                    6108.0,
+                    2936.0,
+                    6068.0,
+                    2956.0,
+                    6028.0,
+                    2996.0,
+                    6028.0,
+                    3036.0,
+                    6008.0,
+                    3086.0,
+                    6008.0,
+                    3146.0,
+                    5998.0,
+                    3176.0,
+                    5958.0,
+                    3156.0,
+                    5908.0,
+                    3126.0,
+                    5868.0,
+                    3076.0,
+                    5828.0,
+                    3076.0,
+                    5788.0,
+                    3056.0,
+                    5708.0,
+                    3056.0,
+                    5628.0,
+                    3026.0,
+                    5588.0,
+                    2986.0,
+                    5518.0,
+                    2936.0,
+                    5498.0,
+                    2856.0,
+                    5498.0,
+                    2796.0,
+                    5498.0,
+                    2756.0,
+                    5508.0,
+                    2676.0,
+                    5508.0,
+                    2636.0,
+                    5528.0,
+                    2556.0,
+                    5538.0,
+                    2486.0,
+                    5538.0,
+                    2386.0,
+                    5548.0,
+                    2386.0,
+                    5548.0,
+                    2256.0,
+                    5548.0,
+                    2196.0,
+                    5558.0,
+                    2136.0,
+                    5568.0,
+                    2136.0,
+                    5568.0,
+                    2066.0,
+                    5578.0,
+                    1956.0,
+                    5568.0,
+                    1906.0,
+                    5588.0,
+                    1866.0,
+                    5588.0,
+                    1796.0,
+                    5588.0,
+                    1746.0,
+                    5588.0,
+                    1676.0,
+                    5598.0,
+                    1636.0,
+                    5598.0,
+                    1556.0,
+                    5598.0,
+                    1396.0,
+                    5578.0,
+                    1366.0,
+                    5578.0,
+                    1326.0,
+                    5568.0,
+                    1296.0,
+                    5548.0,
+                    1266.0,
+                    5548.0,
+                    1216.0,
+                    5558.0,
+                    1196.0,
+                    5548.0,
+                    1136.0,
+                    5548.0,
+                    1096.0,
+                    5548.0,
+                    1036.0,
+                    5568.0,
+                    956.0,
+                    5568.0,
+                    926.0,
+                    5568.0,
+                    926.0,
+                    5568.0,
+                    866.0,
+                    5558.0,
+                    796.0,
+                    5568.0,
+                    796.0,
+                    5568.0,
+                    716.0,
+                    5628.0
+                ]
+            ]
+        },
+        {
+            "id": 36,
+            "image_id": 2,
+            "category_id": 10,
+            "bbox": [
+                893.56,
+                964.85,
+                2206.93,
+                264.36
+            ],
+            "area": 262811.36715000035,
+            "iscrowd": 0,
+            "segmentation": [
+                [
+                    917.33,
+                    1113.37,
+                    893.56,
+                    1143.07,
+                    911.39,
+                    1202.48,
+                    964.85,
+                    1190.59,
+                    994.55,
+                    1229.21,
+                    1027.23,
+                    1223.27,
+                    1053.96,
+                    1190.59,
+                    1104.46,
+                    1190.59,
+                    1146.04,
+                    1199.5,
+                    1244.06,
+                    1190.59,
+                    1327.23,
+                    1190.59,
+                    1451.98,
+                    1184.65,
+                    1520.3,
+                    1172.77,
+                    1650.99,
+                    1187.62,
+                    1743.07,
+                    1190.59,
+                    1850.0,
+                    1181.68,
+                    1962.87,
+                    1166.83,
+                    2069.8,
+                    1160.89,
+                    2188.61,
+                    1160.89,
+                    2262.87,
+                    1163.86,
+                    2349.01,
+                    1154.95,
+                    2470.79,
+                    1143.07,
+                    2562.87,
+                    1157.92,
+                    2684.65,
+                    1149.01,
+                    2794.55,
+                    1131.19,
+                    2874.75,
+                    1131.19,
+                    2978.71,
+                    1128.22,
+                    3076.73,
+                    1116.34,
+                    3097.52,
+                    1056.93,
+                    3100.49,
+                    1009.41,
+                    3032.18,
+                    991.58,
+                    2907.43,
+                    1012.38,
+                    2812.38,
+                    1030.2,
+                    2806.44,
+                    964.85,
+                    2744.06,
+                    970.79,
+                    2711.39,
+                    988.61,
+                    2723.27,
+                    1030.2,
+                    2687.62,
+                    1042.08,
+                    2580.69,
+                    1036.14,
+                    2494.55,
+                    1036.14,
+                    2357.92,
+                    1039.11,
+                    2224.26,
+                    1036.14,
+                    2099.5,
+                    1045.05,
+                    1808.42,
+                    1059.9,
+                    1749.01,
+                    1065.84,
+                    1680.69,
+                    1056.93,
+                    1627.23,
+                    1050.99,
+                    1564.85,
+                    1059.9,
+                    1541.09,
+                    1083.66,
+                    1490.59,
+                    1083.66,
+                    1350.99,
+                    1083.66,
+                    1288.61,
+                    1042.08,
+                    1214.36,
+                    1042.08,
+                    1184.65,
+                    1068.81,
+                    1160.89,
+                    1089.6,
+                    1089.6,
+                    1077.72,
+                    1012.38,
+                    1083.66,
+                    961.88,
+                    1089.6
+                ]
+            ]
+        },
+        {
+            "id": 37,
+            "image_id": 2,
+            "category_id": 10,
+            "bbox": [
+                891,
+                2489,
+                2218,
+                248
+            ],
+            "area": 550064,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 38,
+            "image_id": 2,
+            "category_id": 10,
+            "bbox": [
+                891,
+                2271,
+                2218,
+                316
+            ],
+            "area": 700888,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 39,
+            "image_id": 2,
+            "category_id": 10,
+            "bbox": [
+                853,
+                1201,
+                2012,
+                254
+            ],
+            "area": 511048,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 40,
+            "image_id": 2,
+            "category_id": 10,
+            "bbox": [
+                798,
+                1578,
+                2355,
+                401
+            ],
+            "area": 944355,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 41,
+            "image_id": 2,
+            "category_id": 10,
+            "bbox": [
+                912,
+                2636,
+                2097,
+                348
+            ],
+            "area": 729756,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 42,
+            "image_id": 2,
+            "category_id": 10,
+            "bbox": [
+                884,
+                1931,
+                2168,
+                216
+            ],
+            "area": 468288,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 43,
+            "image_id": 2,
+            "category_id": 10,
+            "bbox": [
+                876,
+                2135,
+                2286,
+                198
+            ],
+            "area": 452628,
+            "iscrowd": 0,
+            "segmentation": []
+        },
+        {
+            "id": 44,
+            "image_id": 2,
+            "category_id": 10,
+            "bbox": [
+                844,
+                1370,
+                2308,
+                248
+            ],
+            "area": 572384,
+            "iscrowd": 0,
+            "segmentation": []
+        }
+    ],
+    "categories": [
+        {
+            "id": 1,
+            "name": "Border",
+            "supercategory": "object"
+        },
+        {
+            "id": 2,
+            "name": "Catchword",
+            "supercategory": "object"
+        },
+        {
+            "id": 3,
+            "name": "Diagram",
+            "supercategory": "object"
+        },
+        {
+            "id": 4,
+            "name": "Embellished",
+            "supercategory": "object"
+        },
+        {
+            "id": 5,
+            "name": "Gloss",
+            "supercategory": "object"
+        },
+        {
+            "id": 6,
+            "name": "Historiated",
+            "supercategory": "object"
+        },
+        {
+            "id": 7,
+            "name": "Ignore",
+            "supercategory": "object"
+        },
+        {
+            "id": 8,
+            "name": "Illustrations",
+            "supercategory": "object"
+        },
+        {
+            "id": 9,
+            "name": "Inhabited",
+            "supercategory": "object"
+        },
+        {
+            "id": 10,
+            "name": "Main script black",
+            "supercategory": "object"
+        },
+        {
+            "id": 11,
+            "name": "Main script coloured",
+            "supercategory": "object"
+        },
+        {
+            "id": 12,
+            "name": "Music",
+            "supercategory": "object"
+        },
+        {
+            "id": 13,
+            "name": "Page Number",
+            "supercategory": "object"
+        },
+        {
+            "id": 14,
+            "name": "Plain initial - Black",
+            "supercategory": "object"
+        },
+        {
+            "id": 15,
+            "name": "Plain initial - Highlighted",
+            "supercategory": "object"
+        },
+        {
+            "id": 16,
+            "name": "Plain initial- coloured",
+            "supercategory": "object"
+        },
+        {
+            "id": 17,
+            "name": "Quire Mark",
+            "supercategory": "object"
+        },
+        {
+            "id": 18,
+            "name": "Running header",
+            "supercategory": "object"
+        },
+        {
+            "id": 19,
+            "name": "Table",
+            "supercategory": "object"
+        },
+        {
+            "id": 20,
+            "name": "Variant script black",
+            "supercategory": "object"
+        },
+        {
+            "id": 21,
+            "name": "Variant script coloured",
+            "supercategory": "object"
+        },
+        {
+            "id": 22,
+            "name": "Zoo - Anthropomorphic",
+            "supercategory": "object"
+        }
+    ]
+}

compare/data/new_models.py

@@ -0,0 +1,137 @@
+"""
+Run new models (emanuskript, catmus, zone) and convert predictions to COCO format.
+Uses the same logic as app.py and test_combined_models.py.
+"""
+import os
+import sys
+import json
+from pathlib import Path
+import tempfile
+
+# Add project root to path
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(os.path.dirname(SCRIPT_DIR))
+sys.path.insert(0, PROJECT_ROOT)
+
+# Import from project root
+from test_combined_models import run_model_predictions, combine_and_filter_predictions
+
+
+def run_new_models_on_image(image_path, conf_threshold=0.25, iou_threshold=0.45):
+    """
+    Run new models on a single image and return COCO format predictions.
+    
+    Args:
+        image_path: Path to image file
+        conf_threshold: Confidence threshold (not directly used, but kept for consistency)
+        iou_threshold: IoU threshold (not directly used, but kept for consistency)
+    
+    Returns:
+        COCO format dictionary with predictions
+    """
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        # Run 3 models and save predictions JSON
+        labels_folders = run_model_predictions(image_path, tmp_dir)
+        
+        # Combine & filter to coco_class_mapping
+        coco_json = combine_and_filter_predictions(
+            image_path, labels_folders, output_json_path=None
+        )
+    
+    return coco_json
+
+
+def process_dataset(images_dir, output_dir, conf_threshold=0.25, iou_threshold=0.45):
+    """
+    Process all images in a directory with new models.
+    
+    Args:
+        images_dir: Directory containing images
+        output_dir: Directory to save COCO JSON files
+        conf_threshold: Confidence threshold
+        iou_threshold: IoU threshold
+    
+    Returns:
+        Merged COCO format dictionary for all images
+    """
+    # Get all image files
+    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tif', '.tiff'}
+    image_files = [
+        f for f in os.listdir(images_dir)
+        if os.path.splitext(f)[1].lower() in image_extensions
+    ]
+    
+    all_coco_dicts = []
+    image_id = 1
+    
+    for image_file in sorted(image_files):
+        image_path = os.path.join(images_dir, image_file)
+        print(f"Processing {image_file}...")
+        
+        try:
+            coco = run_new_models_on_image(
+                image_path,
+                conf_threshold=conf_threshold,
+                iou_threshold=iou_threshold
+            )
+            
+            # Update image ID if needed
+            if len(coco["images"]) > 0:
+                coco["images"][0]["id"] = image_id
+                
+                # Update annotation image_ids
+                for ann in coco["annotations"]:
+                    ann["image_id"] = image_id
+            
+            all_coco_dicts.append(coco)
+            image_id += 1
+            
+            # Save individual file
+            output_path = os.path.join(output_dir, f"{Path(image_file).stem}_new.json")
+            with open(output_path, 'w') as f:
+                json.dump(coco, f, indent=2)
+        
+        except Exception as e:
+            print(f"Error processing {image_file}: {e}")
+            import traceback
+            traceback.print_exc()
+            continue
+    
+    # Merge all COCO dicts
+    merged = {
+        "info": {"description": "New models predictions - merged"},
+        "licenses": [],
+        "images": [],
+        "annotations": [],
+        "categories": []
+    }
+    
+    # Use categories from first COCO (they should all be the same)
+    if len(all_coco_dicts) > 0:
+        merged["categories"] = all_coco_dicts[0]["categories"]
+    
+    # Merge images and annotations
+    ann_id = 1
+    for coco in all_coco_dicts:
+        merged["images"].extend(coco["images"])
+        
+        for ann in coco["annotations"]:
+            new_ann = ann.copy()
+            new_ann["id"] = ann_id
+            merged["annotations"].append(new_ann)
+            ann_id += 1
+    
+    return merged
+
+
+if __name__ == "__main__":
+    # Test on single image
+    test_image = "../../e-codices_bbb-0219_044r_max.jpg"
+    coco = run_new_models_on_image(test_image)
+    
+    print(f"Predictions: {len(coco['annotations'])} annotations")
+    print(f"Categories: {[c['name'] for c in coco['categories']]}")
+    
+    with open("test_new_models.json", "w") as f:
+        json.dump(coco, f, indent=2)
+

compare/data/old_models.py

@@ -0,0 +1,371 @@
+"""
+Run old models (Line, Border, Zones) and convert predictions to COCO format.
+"""
+import os
+import json
+import numpy as np
+from pathlib import Path
+from ultralytics import YOLO, YOLOE
+import tempfile
+from typing import Dict, List
+import pycocotools.mask as mask_util
+import cv2
+
+
+# Model files (same as app_original_app_with_three_models.py)
+MODEL_FILES = {
+    "Line Detection": "best_line_detection_yoloe (1).pt",
+    "Border Detection": "border_model_weights.pt",
+    "Zones Detection": "zones_model_weights.pt"
+}
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(os.path.dirname(SCRIPT_DIR))
+
+
+def load_old_models():
+    """Load the three old models."""
+    models = {}
+    for name, model_file in MODEL_FILES.items():
+        model_path = os.path.join(PROJECT_ROOT, model_file)
+        if os.path.exists(model_path):
+            try:
+                if name == "Line Detection":
+                    models[name] = YOLOE(model_path)
+                else:
+                    models[name] = YOLO(model_path)
+                print(f"✓ Loaded {name} model")
+            except Exception as e:
+                print(f"✗ Error loading {name} model: {e}")
+                models[name] = None
+        else:
+            print(f"✗ Model file not found: {model_path}")
+            models[name] = None
+    return models
+
+
+def results_to_coco(result, model_name, image_id, image_width, image_height, category_map):
+    """
+    Convert YOLO result to COCO format annotations.
+    Handles masks properly for YOLOE Line Detection model (like app.py).
+    
+    Args:
+        result: YOLO Results object (single result, not list)
+        model_name: Name of the model (for special handling)
+        image_id: COCO image ID
+        image_width: Image width
+        image_height: Image height
+        category_map: Dict mapping class names to COCO category IDs
+    
+    Returns:
+        List of COCO annotation dictionaries
+    """
+    annotations = []
+    ann_id = 1
+    
+    if result is None:
+        return annotations
+    
+    # Get boxes and masks
+    boxes = result.boxes
+    if boxes is None:
+        return annotations
+    
+    # Get masks if available
+    masks = result.masks
+    has_masks = masks is not None and len(masks) > 0
+    
+    num_detections = len(boxes)
+    
+    for i in range(num_detections):
+        # Get box coordinates
+        box = boxes.xyxy[i].cpu().numpy()  # [x1, y1, x2, y2]
+        x1, y1, x2, y2 = box
+        
+        # Get class
+        cls_id = int(boxes.cls[i].cpu().numpy())
+        cls_name = result.names[cls_id]
+        
+        # Map "object" to "line" for Line Detection model (like app.py)
+        if model_name == "Line Detection" and cls_name == "object":
+            cls_name = "line"
+        
+        # Skip if class not in category map
+        if cls_name not in category_map:
+            continue
+        
+        # Get confidence
+        conf = float(boxes.conf[i].cpu().numpy())
+        
+        # Convert bbox to COCO format [x, y, width, height]
+        bbox = [float(x1), float(y1), float(x2 - x1), float(y2 - y1)]
+        
+        # Get segmentation
+        segmentation = None
+        area = bbox[2] * bbox[3]  # Default to bbox area
+        
+        if has_masks and i < len(masks.data):
+            try:
+                # Get mask (like app.py handles YOLOE masks)
+                mask = masks.data[i].cpu().numpy()
+                
+                # Handle mask resizing similar to app.py
+                if mask.shape != (image_height, image_width):
+                    # Resize mask to image size using cv2 (like app.py)
+                    mask_np = (mask > 0).astype(np.uint8)
+                    resized_mask = cv2.resize(
+                        mask_np,
+                        (image_width, image_height),
+                        interpolation=cv2.INTER_NEAREST
+                    )
+                    mask = resized_mask.astype(np.uint8)
+                else:
+                    mask = (mask > 0.5).astype(np.uint8)
+                
+                # Convert to COCO RLE format
+                rle = mask_util.encode(np.asfortranarray(mask))
+                if isinstance(rle['counts'], bytes):
+                    rle['counts'] = rle['counts'].decode('utf-8')
+                segmentation = rle
+                area = float(mask_util.area(rle))
+            except Exception as e:
+                print(f"Warning: Failed to convert mask to RLE for detection {i}: {e}")
+                # Fall back to bbox
+                pass
+        
+        # Create COCO annotation
+        ann = {
+            "id": ann_id,
+            "image_id": image_id,
+            "category_id": category_map[cls_name],
+            "bbox": bbox,
+            "area": area,
+            "iscrowd": 0,
+            "score": conf
+        }
+        
+        if segmentation is not None:
+            ann["segmentation"] = segmentation
+        
+        annotations.append(ann)
+        ann_id += 1
+    
+    return annotations
+
+
+def run_old_models_on_image(image_path, models, conf_threshold=0.25, iou_threshold=0.45):
+    """
+    Run old models on a single image and return COCO format predictions.
+    Matches the behavior of app.py for consistent results.
+    
+    Args:
+        image_path: Path to image file
+        models: Dict of loaded models
+        conf_threshold: Confidence threshold
+        iou_threshold: IoU threshold
+    
+    Returns:
+        COCO format dictionary with predictions
+    """
+    # Load image as numpy array (like app.py does)
+    image = cv2.imread(image_path)
+    if image is None:
+        raise ValueError(f"Failed to load image: {image_path}")
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    image_height, image_width = image.shape[:2]
+    
+    # Create category map (map all detected classes to sequential IDs)
+    all_classes = set()
+    results_dict = {}
+    
+    # Run each model
+    for model_name, model in models.items():
+        if model is None:
+            continue
+        
+        try:
+            # Use numpy array for prediction (like app.py)
+            # Access result as [0] immediately (like app.py)
+            result = model.predict(
+                image,
+                conf=conf_threshold,
+                iou=iou_threshold
+            )[0]
+            
+            # Collect class names and map "object" to "line" for Line Detection
+            if result.names:
+                for cls_id, cls_name in result.names.items():
+                    # Map "object" to "line" for Line Detection model (like app.py)
+                    if model_name == "Line Detection" and cls_name == "object":
+                        all_classes.add("line")
+                    else:
+                        all_classes.add(cls_name)
+            
+            results_dict[model_name] = result
+        except Exception as e:
+            print(f"Error running {model_name}: {e}")
+            import traceback
+            traceback.print_exc()
+            results_dict[model_name] = None
+    
+    # Create category mapping
+    category_map = {cls_name: idx + 1 for idx, cls_name in enumerate(sorted(all_classes))}
+    
+    # Convert all results to COCO format
+    all_annotations = []
+    ann_id = 1
+    
+    for model_name, result in results_dict.items():
+        if result is None:
+            continue
+        
+        annotations = results_to_coco(
+            result,
+            model_name,
+            image_id=1,  # Will be set later
+            image_width=image_width,
+            image_height=image_height,
+            category_map=category_map
+        )
+        
+        # Update annotation IDs
+        for ann in annotations:
+            ann["id"] = ann_id
+            ann_id += 1
+        
+        all_annotations.extend(annotations)
+    
+    # Create COCO format
+    coco = {
+        "info": {"description": "Old models predictions"},
+        "licenses": [],
+        "images": [{
+            "id": 1,
+            "width": image_width,
+            "height": image_height,
+            "file_name": os.path.basename(image_path)
+        }],
+        "annotations": all_annotations,
+        "categories": [
+            {"id": cid, "name": name, "supercategory": ""}
+            for name, cid in sorted(category_map.items(), key=lambda x: x[1])
+        ]
+    }
+    
+    return coco
+
+
+def process_dataset(images_dir, output_dir, conf_threshold=0.25, iou_threshold=0.45):
+    """
+    Process all images in a directory with old models.
+    
+    Args:
+        images_dir: Directory containing images
+        output_dir: Directory to save COCO JSON files
+        conf_threshold: Confidence threshold
+        iou_threshold: IoU threshold
+    
+    Returns:
+        Merged COCO format dictionary for all images
+    """
+    # Load models
+    models = load_old_models()
+    
+    # Get all image files
+    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tif', '.tiff'}
+    image_files = [
+        f for f in os.listdir(images_dir)
+        if os.path.splitext(f)[1].lower() in image_extensions
+    ]
+    
+    all_coco_dicts = []
+    image_id = 1
+    
+    for image_file in sorted(image_files):
+        image_path = os.path.join(images_dir, image_file)
+        print(f"Processing {image_file}...")
+        
+        try:
+            coco = run_old_models_on_image(
+                image_path,
+                models,
+                conf_threshold=conf_threshold,
+                iou_threshold=iou_threshold
+            )
+            
+            # Update image ID
+            coco["images"][0]["id"] = image_id
+            
+            # Update annotation image_ids
+            for ann in coco["annotations"]:
+                ann["image_id"] = image_id
+            
+            all_coco_dicts.append(coco)
+            image_id += 1
+            
+            # Save individual file
+            output_path = os.path.join(output_dir, f"{Path(image_file).stem}_old.json")
+            with open(output_path, 'w') as f:
+                json.dump(coco, f, indent=2)
+        
+        except Exception as e:
+            print(f"Error processing {image_file}: {e}")
+            continue
+    
+    # Merge all COCO dicts
+    merged = {
+        "info": {"description": "Old models predictions - merged"},
+        "licenses": [],
+        "images": [],
+        "annotations": [],
+        "categories": []
+    }
+    
+    # Collect all categories
+    all_categories = {}
+    for coco in all_coco_dicts:
+        for cat in coco["categories"]:
+            if cat["name"] not in all_categories:
+                all_categories[cat["name"]] = cat["id"]
+    
+    # Update category IDs to be sequential
+    category_map = {name: idx + 1 for idx, name in enumerate(sorted(all_categories.keys()))}
+    reverse_map = {old_id: category_map[name] for name, old_id in all_categories.items()}
+    
+    merged["categories"] = [
+        {"id": cid, "name": name, "supercategory": ""}
+        for name, cid in sorted(category_map.items(), key=lambda x: x[1])
+    ]
+    
+    # Merge images and annotations
+    ann_id = 1
+    for coco in all_coco_dicts:
+        merged["images"].extend(coco["images"])
+        
+        for ann in coco["annotations"]:
+            new_ann = ann.copy()
+            new_ann["id"] = ann_id
+            # Update category_id using reverse_map
+            old_cat_id = ann["category_id"]
+            # Find category name
+            cat_name = next((c["name"] for c in coco["categories"] if c["id"] == old_cat_id), None)
+            if cat_name and cat_name in category_map:
+                new_ann["category_id"] = category_map[cat_name]
+            merged["annotations"].append(new_ann)
+            ann_id += 1
+    
+    return merged
+
+
+if __name__ == "__main__":
+    # Test on single image
+    test_image = "../../e-codices_bbb-0219_044r_max.jpg"
+    models = load_old_models()
+    coco = run_old_models_on_image(test_image, models)
+    
+    print(f"Predictions: {len(coco['annotations'])} annotations")
+    print(f"Categories: {[c['name'] for c in coco['categories']]}")
+    
+    with open("test_old_models.json", "w") as f:
+        json.dump(coco, f, indent=2)
+

compare/data/original_annotations.py

@@ -0,0 +1,359 @@
+"""
+Parse CVAT XML annotations and convert to COCO format for evaluation.
+"""
+import xml.etree.ElementTree as ET
+import json
+import numpy as np
+from pathlib import Path
+from PIL import Image
+
+try:
+    import pycocotools.mask as mask_util
+    HAS_PYCOCOTOOLS = True
+except ImportError:
+    HAS_PYCOCOTOOLS = False
+    print("Warning: pycocotools not available. Install with: pip install pycocotools")
+
+
+def parse_rle(rle_string, width, height):
+    """
+    Parse RLE (Run-Length Encoding) string from CVAT format.
+    CVAT RLE format is a simple list of counts: "count1, count2, count3, ..."
+    This represents a flattened binary mask where counts alternate between
+    runs of 0s and 1s.
+    """
+    if not rle_string or not rle_string.strip():
+        return None
+    
+    try:
+        # Split by comma and convert to integers
+        counts = [int(x.strip()) for x in rle_string.split(',') if x.strip()]
+        
+        if len(counts) == 0:
+            return None
+        
+        # Create binary mask
+        mask = np.zeros((height, width), dtype=np.uint8)
+        
+        # Parse RLE: counts alternate between 0s and 1s
+        # First count is typically 0s, then 1s, then 0s, etc.
+        pos = 0
+        is_foreground = False  # Start with background (0s)
+        
+        for count in counts:
+            if is_foreground:
+                # Fill foreground pixels
+                for _ in range(count):
+                    y = pos // width
+                    x = pos % width
+                    if y < height and x < width:
+                        mask[y, x] = 1
+                    pos += 1
+            else:
+                # Skip background pixels
+                pos += count
+            
+            is_foreground = not is_foreground
+        
+        # Convert to COCO RLE format
+        try:
+            rle = mask_util.encode(np.asfortranarray(mask))
+            rle['counts'] = rle['counts'].decode('utf-8')
+            return rle
+        except ImportError:
+            # Fallback if pycocotools not available
+            print("Warning: pycocotools not available, using bbox only")
+            return None
+    except Exception as e:
+        print(f"Warning: Failed to parse RLE: {e}")
+        return None
+
+
+def bbox_from_mask(rle, width, height):
+    """Extract bounding box from RLE mask."""
+    if rle is None or not HAS_PYCOCOTOOLS:
+        return None
+    
+    try:
+        # Decode RLE to get mask
+        rle_decoded = rle.copy()
+        rle_decoded['counts'] = rle_decoded['counts'].encode('utf-8')
+        mask = mask_util.decode(rle_decoded)
+        
+        # Find bounding box
+        rows = np.any(mask, axis=1)
+        cols = np.any(mask, axis=0)
+        
+        if not np.any(rows) or not np.any(cols):
+            return None
+        
+        y_min, y_max = np.where(rows)[0][[0, -1]]
+        x_min, x_max = np.where(cols)[0][[0, -1]]
+        
+        # COCO format: [x, y, width, height]
+        return [int(x_min), int(y_min), int(x_max - x_min + 1), int(y_max - y_min + 1)]
+    except Exception as e:
+        print(f"Warning: Failed to extract bbox from mask: {e}")
+        return None
+
+
+def parse_cvat_xml(xml_path, images_dir):
+    """
+    Parse CVAT XML file and convert to COCO format.
+    Handles <box>, <polygon>, and <mask> annotations.
+    
+    Args:
+        xml_path: Path to CVAT annotations.xml file
+        images_dir: Directory containing the images
+    
+    Returns:
+        COCO format dictionary
+    """
+    # 1. Load the XML
+    try:
+        tree = ET.parse(xml_path)
+        root = tree.getroot()
+    except FileNotFoundError:
+        print(f"Error: Could not find XML file: {xml_path}")
+        return None
+    
+    # 2. Initialize COCO structure
+    coco = {
+        "info": {
+            "description": "Converted from CVAT XML",
+            "year": 2024,
+            "version": "1.0"
+        },
+        "licenses": [],
+        "images": [],
+        "annotations": [],
+        "categories": []
+    }
+    
+    # 3. Create Category (Label) Map
+    # First, try to get labels from <label> tags in meta section
+    labels = set()
+    for label in root.findall('.//label'):
+        label_name = label.find('name')
+        if label_name is not None and label_name.text:
+            labels.add(label_name.text)
+    
+    # Also scan images for any labels used in annotations
+    for image in root.findall('image'):
+        for child in image:
+            if child.tag in ['box', 'polygon', 'mask']:
+                label = child.get('label')
+                if label:
+                    labels.add(label)
+    
+    # Sort labels to ensure consistent IDs
+    label_map = {}
+    for i, label_name in enumerate(sorted(list(labels))):
+        category_id = i + 1  # COCO IDs start at 1
+        label_map[label_name] = category_id
+        coco["categories"].append({
+            "id": category_id,
+            "name": label_name,
+            "supercategory": "object"
+        })
+    
+    print(f"Found Categories: {label_map}")
+    
+    # 4. Parse Images and Annotations
+    annotation_id = 1
+    image_id = 1
+    
+    # CVAT images are stored in <image> tags
+    for img_tag in root.findall('image'):
+        file_name = img_tag.get('name')
+        
+        # Check if file exists
+        full_image_path = Path(images_dir) / file_name
+        if not full_image_path.exists():
+            print(f"Warning: Image {file_name} mentioned in XML not found in folder. Processing anyway.")
+        
+        width = int(img_tag.get('width'))
+        height = int(img_tag.get('height'))
+        
+        # Add Image to COCO
+        coco_image = {
+            "id": image_id,
+            "width": width,
+            "height": height,
+            "file_name": file_name
+        }
+        coco["images"].append(coco_image)
+        
+        # Process Bounding Boxes (<box>)
+        for box in img_tag.findall('box'):
+            label = box.get('label')
+            if label not in label_map:
+                continue
+            
+            # CVAT uses Top-Left (xtl, ytl) and Bottom-Right (xbr, ybr)
+            xtl = float(box.get('xtl'))
+            ytl = float(box.get('ytl'))
+            xbr = float(box.get('xbr'))
+            ybr = float(box.get('ybr'))
+            
+            # Convert to COCO format: [x_min, y_min, width, height]
+            w = xbr - xtl
+            h = ybr - ytl
+            bbox = [xtl, ytl, w, h]
+            area = w * h
+            
+            ann = {
+                "id": annotation_id,
+                "image_id": image_id,
+                "category_id": label_map[label],
+                "bbox": bbox,
+                "area": area,
+                "iscrowd": 0,
+                "segmentation": []  # Empty for simple boxes
+            }
+            coco["annotations"].append(ann)
+            annotation_id += 1
+        
+        # Process Polygons (<polygon>)
+        for poly in img_tag.findall('polygon'):
+            label = poly.get('label')
+            if label not in label_map:
+                continue
+            
+            points_str = poly.get('points')  # "x1,y1;x2,y2;..."
+            
+            # Parse points into flat list [x1, y1, x2, y2, ...]
+            points = []
+            for pair in points_str.split(';'):
+                if not pair.strip():
+                    continue
+                x, y = map(float, pair.split(','))
+                points.extend([x, y])
+            
+            if len(points) < 6:  # Need at least 3 points (6 coordinates)
+                continue
+            
+            # Calculate bounding box from polygon
+            x_coords = points[0::2]
+            y_coords = points[1::2]
+            x_min = min(x_coords)
+            y_min = min(y_coords)
+            w = max(x_coords) - x_min
+            h = max(y_coords) - y_min
+            
+            # Calculate polygon area using shoelace formula
+            area = 0.5 * abs(sum(x_coords[i] * y_coords[(i + 1) % len(x_coords)] - 
+                                x_coords[(i + 1) % len(x_coords)] * y_coords[i] 
+                                for i in range(len(x_coords))))
+            
+            ann = {
+                "id": annotation_id,
+                "image_id": image_id,
+                "category_id": label_map[label],
+                "bbox": [x_min, y_min, w, h],
+                "area": area,
+                "iscrowd": 0,
+                "segmentation": [points]
+            }
+            coco["annotations"].append(ann)
+            annotation_id += 1
+        
+        # Process Masks (<mask>)
+        for mask_elem in img_tag.findall('mask'):
+            label_name = mask_elem.get('label')
+            if label_name not in label_map:
+                continue
+            
+            # Get RLE data
+            rle_string = mask_elem.text
+            left = int(mask_elem.get('left', 0))
+            top = int(mask_elem.get('top', 0))
+            mask_width = int(mask_elem.get('width', width))
+            mask_height = int(mask_elem.get('height', height))
+            
+            # Parse RLE
+            rle = parse_rle(rle_string, mask_width, mask_height)
+            if rle is None:
+                # Fallback: try to create bbox from mask attributes
+                bbox = [left, top, mask_width, mask_height]
+                area = mask_width * mask_height
+                ann = {
+                    "id": annotation_id,
+                    "image_id": image_id,
+                    "category_id": label_map[label_name],
+                    "bbox": bbox,
+                    "area": area,
+                    "iscrowd": 0,
+                    "segmentation": []
+                }
+                coco["annotations"].append(ann)
+                annotation_id += 1
+                continue
+            
+            # Get bounding box from mask
+            bbox = bbox_from_mask(rle, mask_width, mask_height)
+            if bbox is None:
+                continue
+            
+            # Adjust bbox coordinates if mask has offset
+            bbox[0] += left
+            bbox[1] += top
+            
+            # Calculate area
+            if HAS_PYCOCOTOOLS:
+                area = mask_util.area(rle)
+            else:
+                # Approximate area from bbox
+                area = bbox[2] * bbox[3]
+            
+            # Create COCO annotation
+            ann = {
+                "id": annotation_id,
+                "image_id": image_id,
+                "category_id": label_map[label_name],
+                "segmentation": rle,
+                "area": float(area),
+                "bbox": bbox,
+                "iscrowd": 0
+            }
+            coco["annotations"].append(ann)
+            annotation_id += 1
+        
+        image_id += 1
+    
+    return coco
+
+
+def load_ground_truth(xml_path, images_dir):
+    """
+    Load ground truth annotations from CVAT XML.
+    
+    Args:
+        xml_path: Path to annotations.xml
+        images_dir: Directory containing images
+    
+    Returns:
+        COCO format dictionary
+    """
+    return parse_cvat_xml(xml_path, images_dir)
+
+
+if __name__ == "__main__":
+    # Test parsing
+    xml_path = "Aleyna 1 (2024)/Annotations/annotations.xml"
+    images_dir = "Aleyna 1 (2024)/Images"
+    output_json = "ground_truth_coco.json"
+    
+    coco = load_ground_truth(xml_path, images_dir)
+    
+    if coco:
+        print(f"\nSuccess! Converted {len(coco['images'])} images and {len(coco['annotations'])} annotations.")
+        print(f"Categories: {[c['name'] for c in coco['categories']]}")
+        
+        # Save to JSON for inspection
+        with open(output_json, "w") as f:
+            json.dump(coco, f, indent=4)
+        print(f"Saved to: {output_json}")
+    else:
+        print("Error: Failed to parse XML file")
+

compare/data/sample_batches_model_comparison_summary.json

@@ -0,0 +1,68 @@
+[
+    {
+        "folder": "SampleBatch2",
+        "old_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "list index out of range"
+        },
+        "new_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "list index out of range"
+        },
+        "old_annotations": 50,
+        "new_annotations": 1465,
+        "gt_annotations": 1437
+    },
+    {
+        "folder": "SampleBatch3",
+        "old_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "list index out of range"
+        },
+        "new_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "list index out of range"
+        },
+        "old_annotations": 50,
+        "new_annotations": 923,
+        "gt_annotations": 909
+    },
+    {
+        "folder": "SampleBatch4",
+        "old_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "list index out of range"
+        },
+        "new_metrics": {
+            "mAP@50": 0.0,
+            "mAP@[.50:.95]": 0.0,
+            "Precision": 0.0,
+            "Recall": 0.0,
+            "F1": 0.0,
+            "error": "list index out of range"
+        },
+        "old_annotations": 50,
+        "new_annotations": 1167,
+        "gt_annotations": 1160
+    }
+]

compare/data/sample_batches_summary.json

@@ -0,0 +1,31 @@
+{
+    "total_batches": 3,
+    "successful": 3,
+    "failed": 0,
+    "results": [
+        {
+            "folder": "SampleBatch2",
+            "status": "success",
+            "images": 25,
+            "annotations": 1437,
+            "categories": 25,
+            "visualizations_path": "/home/hasan/layout/compare/data/SampleBatch2/visualizations"
+        },
+        {
+            "folder": "SampleBatch3",
+            "status": "success",
+            "images": 25,
+            "annotations": 909,
+            "categories": 25,
+            "visualizations_path": "/home/hasan/layout/compare/data/SampleBatch3/visualizations"
+        },
+        {
+            "folder": "SampleBatch4",
+            "status": "success",
+            "images": 25,
+            "annotations": 1160,
+            "categories": 25,
+            "visualizations_path": "/home/hasan/layout/compare/data/SampleBatch4/visualizations"
+        }
+    ]
+}

compare/data/test_models_on_sample_batches.py

@@ -0,0 +1,263 @@
+"""
+Test old models and new models on SampleBatch data.
+Compare both against ground truth and calculate metrics.
+Create side-by-side visualizations: GT | Old Models | New Models
+"""
+import os
+import sys
+import json
+import tempfile
+from pathlib import Path
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+
+# Add paths
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(os.path.dirname(SCRIPT_DIR))
+sys.path.insert(0, SCRIPT_DIR)
+sys.path.insert(0, PROJECT_ROOT)
+
+from old_models import process_dataset as process_old_models, run_old_models_on_image
+from new_models import process_dataset as process_new_models, run_new_models_on_image
+from compare import calculate_metrics, align_categories, draw_coco_annotations_simple
+
+try:
+    from pycocotools.coco import COCO
+    from pycocotools.cocoeval import COCOeval
+    HAS_PYCOCOTOOLS = True
+except ImportError:
+    HAS_PYCOCOTOOLS = False
+    print("Warning: pycocotools not available. Metrics calculation will be limited.")
+
+# No mapping - use old models' actual output directly
+
+# Sample batch folders
+SAMPLE_BATCH_FOLDERS = [
+    "SampleBatch2",
+    "SampleBatch3",
+    "SampleBatch4",
+]
+
+
+# Removed mapping function - use old models' output directly
+
+
+def create_side_by_side_visualization(image_path, gt_coco, old_coco, new_coco, output_path):
+    """
+    Create side-by-side visualization: GT | Old Models | New Models
+    """
+    fig, axes = plt.subplots(1, 3, figsize=(30, 10))
+    
+    # Left: Ground Truth
+    draw_coco_annotations_simple(image_path, gt_coco, "Ground Truth", axes[0])
+    
+    # Middle: Old Models
+    draw_coco_annotations_simple(image_path, old_coco, "Old Models", axes[1])
+    
+    # Right: New Models
+    draw_coco_annotations_simple(image_path, new_coco, "New Models", axes[2])
+    
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"  ✓ Saved comparison to: {output_path}")
+
+
+def process_sample_batch(folder_name, base_dir=None):
+    """
+    Process a single sample batch: test old and new models, calculate metrics, create visualizations.
+    """
+    if base_dir is None:
+        base_dir = SCRIPT_DIR
+    
+    folder_path = Path(base_dir) / folder_name
+    
+    if not folder_path.exists():
+        print(f"⚠️  Warning: Folder not found: {folder_path}")
+        return None
+    
+    print("\n" + "=" * 70)
+    print(f"Processing: {folder_name}")
+    print("=" * 70)
+    
+    # Paths
+    gt_json_path = folder_path / "Annotations" / "instances_default.json"
+    images_dir = folder_path / "Images"
+    output_dir = folder_path / "model_comparison"
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Load ground truth
+    print(f"\n[1/5] Loading ground truth...")
+    with open(gt_json_path, 'r') as f:
+        gt_coco = json.load(f)
+    
+    print(f"  ✓ Loaded {len(gt_coco['images'])} images")
+    print(f"  ✓ Loaded {len(gt_coco['annotations'])} annotations")
+    
+    # Run old models
+    print(f"\n[2/5] Running old models...")
+    old_output_dir = output_dir / "old_models"
+    os.makedirs(old_output_dir, exist_ok=True)
+    
+    try:
+        old_coco = process_old_models(str(images_dir), str(old_output_dir))
+        print(f"  ✓ Generated {len(old_coco['annotations'])} annotations")
+        print(f"  ✓ Categories: {[c['name'] for c in old_coco['categories']]}")
+        
+    except Exception as e:
+        print(f"  ❌ Error running old models: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+    
+    # Run new models
+    print(f"\n[3/5] Running new models...")
+    new_output_dir = output_dir / "new_models"
+    os.makedirs(new_output_dir, exist_ok=True)
+    
+    try:
+        new_coco = process_new_models(str(images_dir), str(new_output_dir))
+        print(f"  ✓ Generated {len(new_coco['annotations'])} annotations")
+        
+    except Exception as e:
+        print(f"  ❌ Error running new models: {e}")
+        import traceback
+        traceback.print_exc()
+        return None
+    
+    # Calculate metrics
+    print(f"\n[4/5] Calculating metrics...")
+    
+    # Align categories with ground truth (by name matching)
+    old_coco_aligned = align_categories(gt_coco.copy(), old_coco.copy())
+    new_coco_aligned = align_categories(gt_coco.copy(), new_coco.copy())
+    
+    # Calculate metrics for old models
+    print(f"\n  Old Models Metrics:")
+    old_metrics = calculate_metrics(gt_coco, old_coco_aligned, str(output_dir))
+    print(f"    mAP@50: {old_metrics.get('mAP@50', 0):.4f}")
+    print(f"    mAP@[.50:.95]: {old_metrics.get('mAP@[.50:.95]', 0):.4f}")
+    print(f"    Precision: {old_metrics.get('Precision', 0):.4f}")
+    print(f"    Recall: {old_metrics.get('Recall', 0):.4f}")
+    
+    # Calculate metrics for new models
+    print(f"\n  New Models Metrics:")
+    new_metrics = calculate_metrics(gt_coco, new_coco_aligned, str(output_dir))
+    print(f"    mAP@50: {new_metrics.get('mAP@50', 0):.4f}")
+    print(f"    mAP@[.50:.95]: {new_metrics.get('mAP@[.50:.95]', 0):.4f}")
+    print(f"    Precision: {new_metrics.get('Precision', 0):.4f}")
+    print(f"    Recall: {new_metrics.get('Recall', 0):.4f}")
+    
+    # Save metrics
+    metrics_path = output_dir / "metrics.json"
+    with open(metrics_path, 'w') as f:
+        json.dump({
+            "old_models": old_metrics,
+            "new_models": new_metrics
+        }, f, indent=4)
+    print(f"  ✓ Saved metrics to: {metrics_path}")
+    
+    # Create visualizations
+    print(f"\n[5/5] Creating side-by-side visualizations...")
+    vis_dir = output_dir / "visualizations"
+    os.makedirs(vis_dir, exist_ok=True)
+    
+    for img_info in gt_coco["images"]:
+        image_name = img_info["file_name"]
+        image_path = images_dir / image_name
+        
+        if not image_path.exists():
+            continue
+        
+        img_id = img_info["id"]
+        
+        # Filter annotations for this image
+        gt_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in gt_coco["annotations"] if a["image_id"] == img_id],
+            "categories": gt_coco["categories"]
+        }
+        
+        old_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in old_coco["annotations"] if a["image_id"] == img_id],
+            "categories": old_coco["categories"]
+        }
+        
+        new_img_coco = {
+            "images": [img_info],
+            "annotations": [a for a in new_coco["annotations"] if a["image_id"] == img_id],
+            "categories": new_coco["categories"]
+        }
+        
+        # Create visualization
+        output_path = vis_dir / f"{Path(image_name).stem}_comparison.png"
+        create_side_by_side_visualization(
+            str(image_path),
+            gt_img_coco,
+            old_img_coco,
+            new_img_coco,
+            str(output_path)
+        )
+    
+    print(f"  ✓ Visualizations saved to: {vis_dir}")
+    
+    return {
+        "folder": folder_name,
+        "old_metrics": old_metrics,
+        "new_metrics": new_metrics,
+        "old_annotations": len(old_coco["annotations"]),
+        "new_annotations": len(new_coco["annotations"]),
+        "gt_annotations": len(gt_coco["annotations"])
+    }
+
+
+def main():
+    """Main function to process all sample batches."""
+    print("=" * 70)
+    print("TESTING MODELS ON SAMPLE BATCHES")
+    print("=" * 70)
+    print(f"\nProcessing {len(SAMPLE_BATCH_FOLDERS)} sample batch folders:")
+    for folder in SAMPLE_BATCH_FOLDERS:
+        print(f"  - {folder}")
+    
+    results = []
+    
+    for folder_name in SAMPLE_BATCH_FOLDERS:
+        result = process_sample_batch(folder_name)
+        if result:
+            results.append(result)
+    
+    # Print summary
+    print("\n" + "=" * 70)
+    print("SUMMARY")
+    print("=" * 70)
+    
+    for r in results:
+        print(f"\n{r['folder']}:")
+        print(f"  Ground Truth: {r['gt_annotations']} annotations")
+        print(f"  Old Models: {r['old_annotations']} annotations")
+        print(f"    mAP@50: {r['old_metrics'].get('mAP@50', 0):.4f}")
+        print(f"    Precision: {r['old_metrics'].get('Precision', 0):.4f}")
+        print(f"    Recall: {r['old_metrics'].get('Recall', 0):.4f}")
+        print(f"  New Models: {r['new_annotations']} annotations")
+        print(f"    mAP@50: {r['new_metrics'].get('mAP@50', 0):.4f}")
+        print(f"    Precision: {r['new_metrics'].get('Precision', 0):.4f}")
+        print(f"    Recall: {r['new_metrics'].get('Recall', 0):.4f}")
+    
+    # Save summary
+    summary_path = Path(SCRIPT_DIR) / "sample_batches_model_comparison_summary.json"
+    with open(summary_path, 'w') as f:
+        json.dump(results, f, indent=4)
+    
+    print(f"\n✓ Summary saved to: {summary_path}")
+    print("\n" + "=" * 70)
+    print("COMPLETE!")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()
+

compare/data/test_old_models.py

@@ -0,0 +1,335 @@
+"""
+Test script for old_models.py to verify it works like app.py
+"""
+import os
+import sys
+import json
+from pathlib import Path
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+import pycocotools.mask as mask_util
+import cv2
+
+# Add paths
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(os.path.dirname(SCRIPT_DIR))
+sys.path.insert(0, SCRIPT_DIR)
+sys.path.insert(0, PROJECT_ROOT)
+
+from old_models import load_old_models, run_old_models_on_image
+
+
+def visualize_annotations(image_path, coco_json, output_path):
+    """
+    Visualize COCO annotations on the image.
+    """
+    img = Image.open(image_path).convert("RGB")
+    fig, ax = plt.subplots(1, 1, figsize=(12, 16))
+    ax.imshow(img)
+    ax.set_title("Old Models Predictions", fontsize=16, fontweight='bold')
+    ax.axis("off")
+    
+    if not coco_json.get("images") or not coco_json.get("annotations"):
+        plt.savefig(output_path, dpi=150, bbox_inches='tight')
+        plt.close()
+        return
+    
+    img_info = coco_json["images"][0]
+    img_id = img_info["id"]
+    anns = [a for a in coco_json["annotations"] if a["image_id"] == img_id]
+    
+    id_to_name = {c["id"]: c["name"] for c in coco_json["categories"]}
+    
+    # Color map
+    colors = plt.cm.tab20(np.linspace(0, 1, 20))
+    color_map = {}
+    
+    # Track label positions to avoid overlap
+    placed_labels = []
+    
+    def find_label_position(bbox, text_width, text_height, image_width, image_height):
+        """Find a good position for label to avoid overlap."""
+        x, y, w, h = bbox
+        candidates = [
+            (x, y - text_height - 5),  # Above top-left
+            (x, y),  # Top-left corner
+            (x + w - text_width, y),  # Top-right corner
+            (x, y + h + 5),  # Below bottom-left
+        ]
+        
+        for pos_x, pos_y in candidates:
+            # Check if position is within image bounds
+            if pos_x < 0 or pos_y < 0 or pos_x + text_width > image_width or pos_y + text_height > image_height:
+                continue
+            
+            # Check overlap with existing labels
+            overlap = False
+            for placed_x, placed_y, placed_w, placed_h in placed_labels:
+                if not (pos_x + text_width < placed_x or pos_x > placed_x + placed_w or
+                        pos_y + text_height < placed_y or pos_y > placed_y + placed_h):
+                    overlap = True
+                    break
+            
+            if not overlap:
+                return pos_x, pos_y
+        
+        # If all positions overlap, use top-left anyway
+        return x, y
+    
+    img_width, img_height = img.size
+    
+    for ann in anns:
+        name = id_to_name.get(ann["category_id"], f"cls_{ann['category_id']}")
+        
+        # Get or assign color
+        if name not in color_map:
+            color_idx = len(color_map) % len(colors)
+            color_map[name] = colors[color_idx]
+        
+        color = color_map[name]
+        
+        # Get bbox
+        bbox = ann.get("bbox", [0, 0, 0, 0])
+        if not bbox or len(bbox) < 4:
+            # Try to get bbox from segmentation
+            segs = ann.get("segmentation", {})
+            if isinstance(segs, dict) and 'counts' in segs:
+                # RLE mask
+                try:
+                    rle = segs
+                    if isinstance(rle['counts'], str):
+                        rle['counts'] = rle['counts'].encode('utf-8')
+                    mask = mask_util.decode(rle)
+                    ys, xs = np.where(mask > 0)
+                    if len(xs) > 0 and len(ys) > 0:
+                        bbox = [float(min(xs)), float(min(ys)), float(max(xs) - min(xs)), float(max(ys) - min(ys))]
+                    else:
+                        continue
+                except Exception as e:
+                    continue
+            elif isinstance(segs, list) and len(segs) > 0:
+                if isinstance(segs[0], list) and len(segs[0]) >= 6:
+                    coords = segs[0]
+                    xs = coords[0::2]
+                    ys = coords[1::2]
+                    bbox = [min(xs), min(ys), max(xs) - min(xs), max(ys) - min(ys)]
+                else:
+                    continue
+            else:
+                continue
+        
+        x, y, w, h = bbox
+        
+        # Draw segmentation or bbox
+        segs = ann.get("segmentation", {})
+        if isinstance(segs, dict) and 'counts' in segs:
+            # RLE mask - draw as filled polygon using contour
+            try:
+                rle = segs
+                if isinstance(rle['counts'], str):
+                    rle['counts'] = rle['counts'].encode('utf-8')
+                mask = mask_util.decode(rle)
+                
+                # Use cv2 to find contours (memory efficient)
+                mask_uint8 = (mask * 255).astype(np.uint8)
+                contours, _ = cv2.findContours(mask_uint8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+                
+                for contour in contours:
+                    if len(contour) > 2:
+                        # Convert contour to list of (x, y) tuples
+                        poly_coords = [(pt[0][0], pt[0][1]) for pt in contour]
+                        poly = patches.Polygon(
+                            poly_coords, closed=True,
+                            edgecolor=color, facecolor=color,
+                            linewidth=2, alpha=0.3
+                        )
+                        ax.add_patch(poly)
+                        poly_edge = patches.Polygon(
+                            poly_coords, closed=True,
+                            edgecolor=color, facecolor="none",
+                            linewidth=2, alpha=0.8
+                        )
+                        ax.add_patch(poly_edge)
+            except Exception as e:
+                # Fall back to bbox
+                rect = patches.Rectangle(
+                    (x, y), w, h,
+                    edgecolor=color, facecolor=color,
+                    linewidth=2, alpha=0.3
+                )
+                ax.add_patch(rect)
+                rect_edge = patches.Rectangle(
+                    (x, y), w, h,
+                    edgecolor=color, facecolor="none",
+                    linewidth=2, alpha=0.8
+                )
+                ax.add_patch(rect_edge)
+        elif isinstance(segs, list) and len(segs) > 0:
+            if isinstance(segs[0], list) and len(segs[0]) >= 6:
+                # Polygon
+                coords = segs[0]
+                xs = coords[0::2]
+                ys = coords[1::2]
+                poly = patches.Polygon(
+                    list(zip(xs, ys)), closed=True,
+                    edgecolor=color, facecolor=color,
+                    linewidth=2, alpha=0.3
+                )
+                ax.add_patch(poly)
+                poly_edge = patches.Polygon(
+                    list(zip(xs, ys)), closed=True,
+                    edgecolor=color, facecolor="none",
+                    linewidth=2, alpha=0.8
+                )
+                ax.add_patch(poly_edge)
+            else:
+                # Fall back to bbox
+                rect = patches.Rectangle(
+                    (x, y), w, h,
+                    edgecolor=color, facecolor=color,
+                    linewidth=2, alpha=0.3
+                )
+                ax.add_patch(rect)
+                rect_edge = patches.Rectangle(
+                    (x, y), w, h,
+                    edgecolor=color, facecolor="none",
+                    linewidth=2, alpha=0.8
+                )
+                ax.add_patch(rect_edge)
+        else:
+            # Bbox only
+            rect = patches.Rectangle(
+                (x, y), w, h,
+                edgecolor=color, facecolor=color,
+                linewidth=2, alpha=0.3
+            )
+            ax.add_patch(rect)
+            rect_edge = patches.Rectangle(
+                (x, y), w, h,
+                edgecolor=color, facecolor="none",
+                linewidth=2, alpha=0.8
+            )
+            ax.add_patch(rect_edge)
+        
+        # Add label
+        text_width = len(name) * 7
+        text_height = 12
+        label_x, label_y = find_label_position(bbox, text_width, text_height, img_width, img_height)
+        placed_labels.append((label_x, label_y, text_width, text_height))
+        
+        edge_color = tuple(color[:3]) if isinstance(color, np.ndarray) else color
+        ax.text(
+            label_x, label_y, name,
+            color='black', fontsize=9, fontweight='bold',
+            bbox=dict(
+                boxstyle="round,pad=0.3",
+                facecolor="white",
+                edgecolor=edge_color,
+                linewidth=2,
+                alpha=0.9,
+            ),
+            zorder=10,
+        )
+    
+    plt.tight_layout()
+    plt.savefig(output_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"  ✓ Saved visualization to: {output_path}")
+
+
+def test_single_image():
+    """Test old models on a single image."""
+    print("=" * 70)
+    print("TESTING OLD MODELS ON SINGLE IMAGE")
+    print("=" * 70)
+    
+    # Find a test image (use first available image from SampleBatch2)
+    test_image_dir = Path(SCRIPT_DIR) / "SampleBatch2" / "Images"
+    if not test_image_dir.exists():
+        print(f"⚠️  Test image directory not found: {test_image_dir}")
+        print("Please provide a test image path.")
+        return
+    
+    # Get first image
+    image_files = list(test_image_dir.glob("*.jpg")) + list(test_image_dir.glob("*.png"))
+    if not image_files:
+        print(f"⚠️  No images found in {test_image_dir}")
+        return
+    
+    test_image_path = image_files[0]
+    print(f"\n📸 Testing with image: {test_image_path.name}")
+    
+    # Load models
+    print("\n[1/3] Loading models...")
+    models = load_old_models()
+    
+    # Check if all models loaded
+    failed_models = [name for name, model in models.items() if model is None]
+    if failed_models:
+        print(f"⚠️  Warning: Some models failed to load: {failed_models}")
+    
+    # Run predictions
+    print(f"\n[2/3] Running predictions...")
+    try:
+        coco = run_old_models_on_image(
+            str(test_image_path),
+            models,
+            conf_threshold=0.25,
+            iou_threshold=0.45
+        )
+        
+        print(f"  ✓ Generated {len(coco['annotations'])} annotations")
+        print(f"  ✓ Categories: {[c['name'] for c in coco['categories']]}")
+        
+        # Count annotations per model/category
+        category_counts = {}
+        for ann in coco['annotations']:
+            cat_id = ann['category_id']
+            cat_name = next((c['name'] for c in coco['categories'] if c['id'] == cat_id), f"cat_{cat_id}")
+            category_counts[cat_name] = category_counts.get(cat_name, 0) + 1
+        
+        print(f"\n  Annotation counts by category:")
+        for cat_name, count in sorted(category_counts.items()):
+            print(f"    - {cat_name}: {count}")
+        
+        # Check for masks (Line Detection should have masks)
+        masks_count = sum(1 for ann in coco['annotations'] if 'segmentation' in ann)
+        print(f"\n  ✓ Annotations with masks: {masks_count}")
+        
+    except Exception as e:
+        print(f"  ❌ Error running predictions: {e}")
+        import traceback
+        traceback.print_exc()
+        return
+    
+    # Save results
+    print(f"\n[3/4] Saving results...")
+    output_path = Path(SCRIPT_DIR) / "test_old_models_output.json"
+    with open(output_path, 'w') as f:
+        json.dump(coco, f, indent=2)
+    
+    print(f"  ✓ Saved to: {output_path}")
+    
+    # Visualize annotations
+    print(f"\n[4/4] Creating visualization...")
+    vis_output_path = Path(SCRIPT_DIR) / "test_old_models_visualization.png"
+    try:
+        visualize_annotations(str(test_image_path), coco, str(vis_output_path))
+    except Exception as e:
+        print(f"  ⚠️  Warning: Failed to create visualization: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    print("\n" + "=" * 70)
+    print("TEST COMPLETE!")
+    print("=" * 70)
+    print(f"\n📊 Results saved:")
+    print(f"  - JSON: {output_path}")
+    print(f"  - Visualization: {vis_output_path}")
+
+
+if __name__ == "__main__":
+    test_single_image()
+

compare/data/visualize_ground_truth.py

@@ -0,0 +1,330 @@
+"""
+Visualize ground truth annotations from COCO format on images.
+This helps verify the accuracy of XML to COCO conversion.
+"""
+import os
+import json
+import sys
+from pathlib import Path
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+import matplotlib.colors as mcolors
+
+# Add current directory to path
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+from original_annotations import load_ground_truth
+
+try:
+    import pycocotools.mask as mask_util
+    HAS_PYCOCOTOOLS = True
+except ImportError:
+    HAS_PYCOCOTOOLS = False
+    print("Warning: pycocotools not available. Mask visualization may be limited.")
+
+
+def decode_rle(rle, width, height):
+    """Decode COCO RLE to binary mask."""
+    if not HAS_PYCOCOTOOLS:
+        return None
+    try:
+        rle_decoded = rle.copy()
+        rle_decoded['counts'] = rle_decoded['counts'].encode('utf-8')
+        mask = mask_util.decode(rle_decoded)
+        return mask
+    except Exception as e:
+        print(f"Warning: Failed to decode RLE: {e}")
+        return None
+
+
+def draw_coco_annotations(image_path, coco_json, output_path=None, show_labels=True):
+    """
+    Draw COCO annotations on an image.
+    
+    Args:
+        image_path: Path to image file
+        coco_json: COCO format dictionary
+        output_path: Path to save visualized image (if None, returns numpy array)
+        show_labels: Whether to show class labels
+    
+    Returns:
+        numpy array of visualized image (if output_path is None)
+    """
+    # Load image
+    img = Image.open(image_path).convert("RGB")
+    img_array = np.array(img)
+    
+    # Get image info from COCO
+    image_name = os.path.basename(image_path)
+    img_info = None
+    for img_data in coco_json["images"]:
+        if img_data["file_name"] == image_name:
+            img_info = img_data
+            break
+    
+    if img_info is None:
+        print(f"Warning: Image {image_name} not found in COCO data")
+        return img_array
+    
+    img_id = img_info["id"]
+    
+    # Get annotations for this image
+    annotations = [a for a in coco_json["annotations"] if a["image_id"] == img_id]
+    
+    if len(annotations) == 0:
+        print(f"No annotations found for {image_name}")
+        return img_array
+    
+    # Create category name map
+    id_to_name = {c["id"]: c["name"] for c in coco_json["categories"]}
+    
+    # Create figure
+    fig, ax = plt.subplots(1, 1, figsize=(15, 20))
+    ax.imshow(img_array)
+    ax.axis("off")
+    ax.set_title(f"{image_name}\n({len(annotations)} annotations)", 
+                 fontsize=14, fontweight='bold', pad=20)
+    
+    # Generate distinct colors for each category
+    num_categories = len(coco_json["categories"])
+    colors = plt.cm.tab20(np.linspace(0, 1, min(20, num_categories)))
+    if num_categories > 20:
+        # Use additional colormap for more categories
+        colors2 = plt.cm.Set3(np.linspace(0, 1, num_categories - 20))
+        colors = np.vstack([colors, colors2])
+    
+    category_colors = {}
+    for idx, cat in enumerate(coco_json["categories"]):
+        category_colors[cat["id"]] = colors[idx % len(colors)]
+    
+    # Draw each annotation
+    for ann in annotations:
+        cat_id = ann["category_id"]
+        cat_name = id_to_name.get(cat_id, f"category_{cat_id}")
+        color = category_colors.get(cat_id, [1, 0, 0, 0.5])  # Red fallback
+        
+        # Get segmentation
+        segs = ann.get("segmentation", [])
+        bbox = ann.get("bbox", [0, 0, 0, 0])
+        
+        # Draw segmentation (polygon or mask)
+        if segs:
+            if isinstance(segs, list) and len(segs) > 0:
+                # Check if it's RLE (dict) or polygon (list of coordinates)
+                if isinstance(segs, dict) or (isinstance(segs, list) and len(segs) > 0 and isinstance(segs[0], dict)):
+                    # RLE mask
+                    if isinstance(segs, list):
+                        rle = segs[0]
+                    else:
+                        rle = segs
+                    
+                    if HAS_PYCOCOTOOLS:
+                        mask = decode_rle(rle, img_info["width"], img_info["height"])
+                        if mask is not None:
+                            # Draw mask with transparency
+                            mask_colored = np.zeros((*mask.shape, 4))
+                            mask_colored[mask > 0] = [*color[:3], 0.3]  # Semi-transparent fill
+                            ax.imshow(mask_colored, alpha=0.5)
+                            
+                            # Draw mask outline
+                            try:
+                                from scipy import ndimage
+                                contours = ndimage.binary_erosion(mask) ^ mask
+                                ax.contour(contours, colors=[color[:3]], linewidths=2, alpha=0.8)
+                            except ImportError:
+                                # Fallback: just draw the mask without contour
+                                pass
+                
+                elif isinstance(segs[0], list) and len(segs[0]) >= 6:
+                    # Polygon: flat list [x1, y1, x2, y2, ...]
+                    coords = segs[0]
+                    xs = coords[0::2]
+                    ys = coords[1::2]
+                    
+                    # Draw polygon with fill
+                    poly = patches.Polygon(
+                        list(zip(xs, ys)),
+                        closed=True,
+                        edgecolor=color[:3],
+                        facecolor=color[:3],
+                        linewidth=2.5,
+                        alpha=0.3,  # Semi-transparent fill
+                    )
+                    ax.add_patch(poly)
+                    
+                    # Draw polygon outline
+                    poly_edge = patches.Polygon(
+                        list(zip(xs, ys)),
+                        closed=True,
+                        edgecolor=color[:3],
+                        facecolor="none",
+                        linewidth=2.5,
+                        alpha=0.8,  # More opaque edge
+                    )
+                    ax.add_patch(poly_edge)
+        
+        # Draw bounding box if no segmentation or as fallback
+        if not segs or (isinstance(segs, list) and len(segs) == 0):
+            x, y, w, h = bbox
+            if w > 0 and h > 0:
+                rect = patches.Rectangle(
+                    (x, y),
+                    w,
+                    h,
+                    edgecolor=color[:3],
+                    facecolor=color[:3],
+                    linewidth=2.5,
+                    alpha=0.3,
+                )
+                ax.add_patch(rect)
+                
+                # Draw bbox outline
+                rect_edge = patches.Rectangle(
+                    (x, y),
+                    w,
+                    h,
+                    edgecolor=color[:3],
+                    facecolor="none",
+                    linewidth=2.5,
+                    alpha=0.8,
+                )
+                ax.add_patch(rect_edge)
+        
+        # Add label
+        if show_labels:
+            # Get position for label (use bbox or polygon center)
+            if segs and isinstance(segs, list) and len(segs) > 0:
+                if isinstance(segs[0], list) and len(segs[0]) >= 6:
+                    # Polygon
+                    coords = segs[0]
+                    xs = coords[0::2]
+                    ys = coords[1::2]
+                    label_x = min(xs)
+                    label_y = min(ys) - 10
+                else:
+                    # Use bbox
+                    x, y, w, h = bbox
+                    label_x = x
+                    label_y = y - 10
+            else:
+                x, y, w, h = bbox
+                label_x = x
+                label_y = y - 10
+            
+            # Draw label with background
+            ax.text(
+                label_x,
+                label_y,
+                cat_name,
+                color='black',
+                fontsize=10,
+                fontweight='bold',
+                bbox=dict(
+                    boxstyle="round,pad=0.5",
+                    facecolor="white",
+                    edgecolor=color[:3],
+                    linewidth=2,
+                    alpha=0.9,
+                ),
+                zorder=10,
+            )
+    
+    plt.tight_layout()
+    
+    if output_path:
+        plt.savefig(output_path, dpi=150, bbox_inches='tight', facecolor='white')
+        plt.close()
+        print(f"Saved visualization to: {output_path}")
+        return None
+    else:
+        # Return as numpy array
+        fig.canvas.draw()
+        buf = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)
+        buf = buf.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+        plt.close()
+        return buf
+
+
+def visualize_all_images(coco_json, images_dir, output_dir):
+    """
+    Visualize annotations for all images in the COCO dataset.
+    
+    Args:
+        coco_json: COCO format dictionary
+        images_dir: Directory containing images
+        output_dir: Directory to save visualized images
+    """
+    os.makedirs(output_dir, exist_ok=True)
+    
+    print(f"Visualizing {len(coco_json['images'])} images...")
+    
+    for img_info in coco_json["images"]:
+        image_name = img_info["file_name"]
+        image_path = Path(images_dir) / image_name
+        
+        if not image_path.exists():
+            print(f"Warning: Image {image_name} not found, skipping...")
+            continue
+        
+        output_path = Path(output_dir) / f"{Path(image_name).stem}_annotated.png"
+        
+        print(f"Processing {image_name}...")
+        draw_coco_annotations(
+            str(image_path),
+            coco_json,
+            output_path=str(output_path),
+            show_labels=True
+        )
+    
+    print(f"\nAll visualizations saved to: {output_dir}")
+
+
+def main():
+    """Main function to visualize ground truth annotations."""
+    # Paths
+    data_dir = os.path.join(SCRIPT_DIR, "Aleyna 1 (2024)")
+    xml_path = os.path.join(data_dir, "Annotations", "annotations.xml")
+    images_dir = os.path.join(data_dir, "Images")
+    output_dir = os.path.join(SCRIPT_DIR, "visualizations_gt")
+    
+    # Option 1: Load from existing COCO JSON
+    coco_json_path = os.path.join(SCRIPT_DIR, "ground_truth_coco.json")
+    if os.path.exists(coco_json_path):
+        print(f"Loading COCO JSON from: {coco_json_path}")
+        with open(coco_json_path, 'r') as f:
+            coco_json = json.load(f)
+    else:
+        # Option 2: Generate from XML
+        print(f"Loading from XML: {xml_path}")
+        coco_json = load_ground_truth(xml_path, images_dir)
+        
+        if coco_json:
+            # Save for future use
+            with open(coco_json_path, 'w') as f:
+                json.dump(coco_json, f, indent=4)
+            print(f"Saved COCO JSON to: {coco_json_path}")
+    
+    if not coco_json:
+        print("Error: Failed to load annotations")
+        return
+    
+    print(f"\nLoaded {len(coco_json['images'])} images")
+    print(f"Loaded {len(coco_json['annotations'])} annotations")
+    print(f"Categories: {[c['name'] for c in coco_json['categories']]}")
+    
+    # Visualize all images
+    visualize_all_images(coco_json, images_dir, output_dir)
+    
+    print("\n" + "=" * 60)
+    print("Visualization complete!")
+    print("=" * 60)
+    print(f"\nCheck the visualizations in: {output_dir}")
+    print("Compare them with the original images to verify conversion accuracy.")
+
+
+if __name__ == "__main__":
+    main()
+

compare/data/visualize_sample_batches.py

@@ -0,0 +1,198 @@
+"""
+Visualize annotations for SampleBatch2, SampleBatch3, and SampleBatch4.
+These folders already have COCO format JSON files, so we just need to visualize them.
+"""
+import os
+import json
+import sys
+from pathlib import Path
+
+# Add current directory to path
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+from visualize_ground_truth import visualize_all_images, draw_coco_annotations
+
+
+# List of sample batch folders
+SAMPLE_BATCH_FOLDERS = [
+    "SampleBatch2",
+    "SampleBatch3",
+    "SampleBatch4",
+]
+
+
+def visualize_sample_batch(folder_name, base_dir=None):
+    """
+    Visualize annotations for a sample batch folder.
+    
+    Args:
+        folder_name: Name of the sample batch folder
+        base_dir: Base directory containing the folders (default: SCRIPT_DIR)
+    
+    Returns:
+        dict with processing results
+    """
+    if base_dir is None:
+        base_dir = SCRIPT_DIR
+    
+    folder_path = Path(base_dir) / folder_name
+    
+    if not folder_path.exists():
+        print(f"⚠️  Warning: Folder not found: {folder_path}")
+        return {
+            "folder": folder_name,
+            "status": "not_found",
+            "images": 0,
+            "annotations": 0
+        }
+    
+    print("\n" + "=" * 70)
+    print(f"Processing: {folder_name}")
+    print("=" * 70)
+    
+    # Paths
+    json_path = folder_path / "Annotations" / "instances_default.json"
+    images_dir = folder_path / "Images"
+    
+    # Check if required files/directories exist
+    if not json_path.exists():
+        print(f"⚠️  Warning: JSON file not found: {json_path}")
+        return {
+            "folder": folder_name,
+            "status": "no_json",
+            "images": 0,
+            "annotations": 0
+        }
+    
+    if not images_dir.exists():
+        print(f"⚠️  Warning: Images directory not found: {images_dir}")
+        return {
+            "folder": folder_name,
+            "status": "no_images",
+            "images": 0,
+            "annotations": 0
+        }
+    
+    # Load COCO JSON
+    print(f"\n[Loading COCO JSON]")
+    print(f"  JSON: {json_path}")
+    print(f"  Images: {images_dir}")
+    
+    try:
+        with open(json_path, 'r') as f:
+            coco_json = json.load(f)
+        
+        # Verify it's COCO format
+        if not all(key in coco_json for key in ['images', 'annotations', 'categories']):
+            print(f"⚠️  Warning: JSON file doesn't appear to be in COCO format")
+            print(f"  Keys found: {list(coco_json.keys())}")
+            return {
+                "folder": folder_name,
+                "status": "invalid_format",
+                "images": 0,
+                "annotations": 0
+            }
+        
+        num_images = len(coco_json["images"])
+        num_annotations = len(coco_json["annotations"])
+        num_categories = len(coco_json["categories"])
+        
+        print(f"  ✓ Loaded {num_images} images")
+        print(f"  ✓ Loaded {num_annotations} annotations")
+        print(f"  ✓ Loaded {num_categories} categories")
+        
+        # Create visualizations directory inside the folder
+        vis_output_dir = folder_path / "visualizations"
+        
+        print(f"\n[Creating visualizations]")
+        visualize_all_images(coco_json, str(images_dir), str(vis_output_dir))
+        
+        print(f"  ✓ Visualizations saved to: {vis_output_dir}")
+        
+        return {
+            "folder": folder_name,
+            "status": "success",
+            "images": num_images,
+            "annotations": num_annotations,
+            "categories": num_categories,
+            "visualizations_path": str(vis_output_dir)
+        }
+        
+    except json.JSONDecodeError as e:
+        print(f"❌ Error: Invalid JSON file: {e}")
+        return {
+            "folder": folder_name,
+            "status": "json_error",
+            "error": str(e),
+            "images": 0,
+            "annotations": 0
+        }
+    except Exception as e:
+        print(f"❌ Error processing {folder_name}: {e}")
+        import traceback
+        traceback.print_exc()
+        return {
+            "folder": folder_name,
+            "status": "error",
+            "error": str(e),
+            "images": 0,
+            "annotations": 0
+        }
+
+
+def main():
+    """Main function to visualize all sample batches."""
+    print("=" * 70)
+    print("VISUALIZING SAMPLE BATCHES")
+    print("=" * 70)
+    print(f"\nProcessing {len(SAMPLE_BATCH_FOLDERS)} sample batch folders:")
+    for folder in SAMPLE_BATCH_FOLDERS:
+        print(f"  - {folder}")
+    
+    results = []
+    
+    for folder_name in SAMPLE_BATCH_FOLDERS:
+        result = visualize_sample_batch(folder_name)
+        results.append(result)
+    
+    # Print summary
+    print("\n" + "=" * 70)
+    print("PROCESSING SUMMARY")
+    print("=" * 70)
+    
+    successful = [r for r in results if r["status"] == "success"]
+    failed = [r for r in results if r["status"] != "success"]
+    
+    print(f"\n✓ Successfully processed: {len(successful)}/{len(results)}")
+    for r in successful:
+        print(f"  - {r['folder']}: {r['images']} images, {r['annotations']} annotations, {r['categories']} categories")
+    
+    if failed:
+        print(f"\n⚠️  Failed/Skipped: {len(failed)}/{len(results)}")
+        for r in failed:
+            print(f"  - {r['folder']}: {r['status']}")
+            if 'error' in r:
+                print(f"    Error: {r['error']}")
+    
+    # Save summary to JSON
+    summary_path = Path(SCRIPT_DIR) / "sample_batches_summary.json"
+    with open(summary_path, 'w') as f:
+        json.dump({
+            "total_batches": len(SAMPLE_BATCH_FOLDERS),
+            "successful": len(successful),
+            "failed": len(failed),
+            "results": results
+        }, f, indent=4)
+    
+    print(f"\n✓ Summary saved to: {summary_path}")
+    print("\n" + "=" * 70)
+    print("VISUALIZATION COMPLETE!")
+    print("=" * 70)
+    print("\nEach sample batch folder now contains:")
+    print("  - visualizations/ (annotated images)")
+
+
+if __name__ == "__main__":
+    main()
+

test_combined_models.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""
+Script to combine predictions from three YOLO models:
+- best_emanuskript_segmentation.pt (segmentation model for manuscript elements)
+- best_catmus.pt (segmentation model for lines and zones)
+- best_zone_detection.pt (detection model for zones)
+
+WORKFLOW SUMMARY:
+================
+
+1. MODEL PREDICTIONS (run_model_predictions):
+   - Runs each of the 3 models on the input image
+   - Saves predictions to JSON files in separate folders
+   - Emanuskript: detects manuscript elements (Main script, Plain initial, etc.)
+   - Catmus: detects lines (DefaultLine, InterlinearLine)
+   - Zone: detects zones (MainZone, DropCapitalZone, etc.)
+
+2. COMBINING & FILTERING (combine_and_filter_predictions):
+   - Uses ImageBatch class to:
+     a) Load all predictions from the 3 JSON files
+     b) Unify class names (maps catmus/zone names to coco_class_mapping)
+     c) Filter overlapping/conflicting annotations using spatial indexing
+     d) Convert to COCO format
+   - Only keeps classes defined in coco_class_mapping (25 classes total)
+
+3. OUTPUT:
+   - COCO format JSON file with filtered annotations
+   - Only contains classes from coco_class_mapping
+
+KEY CLASSES IN coco_class_mapping:
+- Main script black/coloured
+- Variant script black/coloured  
+- Plain initial (coloured/highlighted/black)
+- Historiated, Inhabited, Embellished
+- Page Number, Quire Mark, Running header
+- Gloss, Illustrations, Column
+- Music, MusicZone, MusicLine
+- Border, Table, Diagram
+- GraphicZone
+
+The ImageBatch class handles:
+- Spatial overlap detection (removes duplicates)
+- Class name unification (catmus_zones_mapping)
+- Annotation filtering based on overlap thresholds
+"""
+
+import os
+import json
+import tempfile
+import shutil
+from pathlib import Path
+from ultralytics import YOLO
+import sys
+
+# Add current directory to path to import ImageBatch
+current_dir = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = current_dir  # This file is in the project root
+sys.path.insert(0, current_dir)
+
+try:
+    from utils.image_batch_classes import ImageBatch, coco_class_mapping
+except ImportError as e:
+    print(f"Warning: Could not import ImageBatch: {e}")
+    print("Make sure all dependencies are installed (rtree, shapely, etc.)")
+    ImageBatch = None
+
+def run_model_predictions(image_path, output_dir):
+    """Run all three models on the image and save predictions."""
+    
+    # Create output directories
+    catmus_dir = os.path.join(output_dir, 'catmus')
+    emanuskript_dir = os.path.join(output_dir, 'emanuskript')
+    zone_dir = os.path.join(output_dir, 'zone')
+    
+    for dir_path in [catmus_dir, emanuskript_dir, zone_dir]:
+        os.makedirs(dir_path, exist_ok=True)
+    
+    image_id = Path(image_path).stem
+    
+    print("=" * 60)
+    print("Running Model Predictions")
+    print("=" * 60)
+    
+    # 1. Emanuskript model
+    print("\n[1/3] Running emanuskript segmentation model...")
+    emanuskript_model_path = os.path.join(PROJECT_ROOT, "best_emanuskript_segmentation.pt")
+    emanuskript_model = YOLO(emanuskript_model_path)
+    emanuskript_classes = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,20]
+    emanuskript_results = emanuskript_model.predict(
+        image_path,
+        classes=emanuskript_classes,
+        iou=0.3,
+        device='cpu',
+        augment=False,
+        stream=False
+    )
+    emanuskript_path = f'{emanuskript_dir}/{image_id}.json'
+    with open(emanuskript_path, 'w') as f:
+        f.write(emanuskript_results[0].to_json())
+    print(f"  ✓ Saved to: {emanuskript_path}")
+    del emanuskript_model
+    del emanuskript_results
+    
+    # 2. Catmus model
+    print("\n[2/3] Running catmus segmentation model...")
+    catmus_model_path = os.path.join(PROJECT_ROOT, "best_catmus.pt")
+    catmus_model = YOLO(catmus_model_path)
+    catmus_classes = [1, 7]  # DefaultLine and InterlinearLine
+    catmus_results = catmus_model.predict(
+        image_path,
+        classes=catmus_classes,
+        iou=0.3,
+        device='cpu',
+        augment=False,
+        stream=False
+    )
+    catmus_path = f'{catmus_dir}/{image_id}.json'
+    with open(catmus_path, 'w') as f:
+        f.write(catmus_results[0].to_json())
+    print(f"  ✓ Saved to: {catmus_path}")
+    del catmus_model
+    del catmus_results
+    
+    # 3. Zone detection model
+    print("\n[3/3] Running zone detection model...")
+    zone_model_path = os.path.join(PROJECT_ROOT, "best_zone_detection.pt")
+    zone_model = YOLO(zone_model_path)
+    zone_results = zone_model.predict(
+        image_path,
+        device='cpu',
+        iou=0.3,
+        augment=False,
+        stream=False
+    )
+    zone_path = f'{zone_dir}/{image_id}.json'
+    with open(zone_path, 'w') as f:
+        f.write(zone_results[0].to_json())
+    print(f"  ✓ Saved to: {zone_path}")
+    del zone_model
+    del zone_results
+    
+    return {
+        'catmus': catmus_dir,
+        'emanuskript': emanuskript_dir,
+        'zone': zone_dir
+    }
+
+
+def combine_and_filter_predictions(image_path, labels_folders, output_json_path=None):
+    """Combine predictions from all models and filter to coco_class_mapping classes."""
+    
+    print("\n" + "=" * 60)
+    print("Combining and Filtering Predictions")
+    print("=" * 60)
+    
+    if ImageBatch is None:
+        print("\nERROR: ImageBatch class not available.")
+        print("Please install missing dependencies:")
+        print("  pip install rtree shapely")
+        return None
+    
+    # Create a temporary folder with just the image file
+    # ImageBatch.load_images() loads all files in the folder, so we need only images
+    temp_image_dir = tempfile.mkdtemp()
+    image_filename = os.path.basename(image_path)
+    temp_image_path = os.path.join(temp_image_dir, image_filename)
+    shutil.copy2(image_path, temp_image_path)
+    
+    # Create ImageBatch instance
+    image_folder = temp_image_dir
+    
+    image_batch = ImageBatch(
+        image_folder=image_folder,
+        catmus_labels_folder=labels_folders['catmus'],
+        emanuskript_labels_folder=labels_folders['emanuskript'],
+        zone_labels_folder=labels_folders['zone']
+    )
+    
+    # Load images
+    print("\n[Step 1] Loading images...")
+    image_batch.load_images()
+    print(f"  ✓ Loaded {len(image_batch.images)} image(s)")
+    
+    # Load annotations from all three models
+    print("\n[Step 2] Loading annotations from all models...")
+    image_batch.load_annotations()
+    
+    total_annotations = sum(len(img.annotations) for img in image_batch.images)
+    print(f"  ✓ Loaded {total_annotations} total annotations")
+    
+    # Unify names (maps catmus/zone names to coco_class_mapping names)
+    print("\n[Step 3] Unifying class names...")
+    image_batch.unify_names()
+    
+    # Filter annotations (removes overlapping/conflicting annotations)
+    print("\n[Step 4] Filtering annotations...")
+    for img in image_batch.images:
+        filtered = img.filter_annotations()
+        print(f"  Image {img.filename}: {len(img.annotations)} -> {len(filtered)} annotations")
+    
+    # Get COCO format JSON
+    print("\n[Step 5] Generating COCO format...")
+    coco_json = image_batch.return_coco_file()
+    
+    # Filter to only classes in coco_class_mapping
+    valid_category_ids = set(coco_class_mapping.values())
+    
+    filtered_annotations = [
+        ann for ann in coco_json['annotations']
+        if ann['category_id'] in valid_category_ids
+    ]
+    
+    coco_json['annotations'] = filtered_annotations
+    
+    # Update categories to only include valid ones
+    coco_json['categories'] = [
+        cat for cat in coco_json['categories']
+        if cat['id'] in valid_category_ids
+    ]
+    
+    print(f"  ✓ Final annotations: {len(filtered_annotations)}")
+    print(f"  ✓ Final categories: {len(coco_json['categories'])}")
+    
+    # Save to file if path provided
+    if output_json_path:
+        with open(output_json_path, 'w') as f:
+            json.dump(coco_json, f, indent=2)
+        print(f"\n  ✓ Saved COCO JSON to: {output_json_path}")
+    
+    # Cleanup temporary image directory
+    shutil.rmtree(temp_image_dir, ignore_errors=True)
+    
+    return coco_json
+
+
+def print_summary(coco_json):
+    """Print summary of results."""
+    print("\n" + "=" * 60)
+    print("Results Summary")
+    print("=" * 60)
+    
+    # Category counts
+    category_counts = {}
+    for ann in coco_json['annotations']:
+        cat_id = ann['category_id']
+        category_counts[cat_id] = category_counts.get(cat_id, 0) + 1
+    
+    # Map category IDs to names
+    id_to_name = {cat['id']: cat['name'] for cat in coco_json['categories']}
+    
+    print(f"\nTotal Annotations: {len(coco_json['annotations'])}")
+    print(f"Total Categories: {len(coco_json['categories'])}")
+    print(f"\nAnnotations per Category:")
+    for cat_id in sorted(category_counts.keys()):
+        name = id_to_name.get(cat_id, f"Unknown({cat_id})")
+        count = category_counts[cat_id]
+        print(f"  {name:30s}: {count:4d}")
+
+
+def visualize_results(image_path, coco_json):
+    """Visualize the combined results on the image."""
+    print("\n" + "=" * 60)
+    print("Visualizing Results")
+    print("=" * 60)
+    
+    try:
+        from utils.image_batch_classes import ImageBatch
+        import tempfile
+        
+        # Create temporary labels folders for visualization
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # We need to recreate the ImageBatch with the combined results
+            # For now, just show the COCO JSON structure
+            print("\nTo visualize, you can:")
+            print("1. Use the COCO JSON file with any COCO visualization tool")
+            print("2. Load the JSON in your annotation tool")
+            print("3. Use the ImageBatch.plot_annotations() method")
+            
+    except Exception as e:
+        print(f"Visualization not available: {e}")
+
+
+def main():
+    """Main function to run the complete pipeline."""
+    
+    # Configuration
+    image_path = "bnf-naf-10039__page-001-of-004.jpg"
+    output_json = "combined_predictions.json"
+    
+    if not os.path.exists(image_path):
+        print(f"Error: Image file not found: {image_path}")
+        return
+    
+    # Create temporary directory for predictions
+    with tempfile.TemporaryDirectory() as temp_dir:
+        print(f"Using temporary directory: {temp_dir}")
+        
+        # Step 1: Run all three models
+        labels_folders = run_model_predictions(image_path, temp_dir)
+        
+        # Step 2: Combine and filter predictions
+        coco_json = combine_and_filter_predictions(
+            image_path,
+            labels_folders,
+            output_json_path=output_json
+        )
+        
+        # Step 3: Print summary
+        print_summary(coco_json)
+        
+        # Step 4: Visualize (optional)
+        visualize_results(image_path, coco_json)
+        
+        print("\n" + "=" * 60)
+        print("Pipeline Complete!")
+        print("=" * 60)
+        print(f"\nOutput saved to: {output_json}")
+
+
+if __name__ == "__main__":
+    main()
+