feat: scope detection QA to inference coverage

backend/app/services/detection_service.py

@@ -15,6 +15,7 @@ from app.core.errors import AppError
 from app.models import AnalysisRun, Dataset, Detection, Job, Project, VectorFeature
 from app.schemas.detection import DetectionListResponse, DetectionRead, DetectionRunListResponse, DetectionRunRead, DetectionRunResponse
 from app.services.detection_georeferencing import pixel_bbox_to_epsg4326_polygon
+from app.services.detection_qa_service import DetectionQaService
 from app.services.model_asset_catalog_service import ModelAssetCatalogService
 from app.services.model_registry_service import ModelRegistryService
 from app.services.qa_service import QaService
@@ -295,13 +296,91 @@ class DetectionService:
                 status_code=422,
             )
 
-        candidate_geometries = [({"id": str(row.id), "class_name": row.class_name}, to_shape(row.geometry)) for row in detections]
-        reference_geometries = [({"id": str(row.id), "feature_class": row.feature_class}, to_shape(row.geometry)) for row in references]
+        raw_candidate_geometries = [({"id": str(row.id), "class_name": row.class_name}, to_shape(row.geometry)) for row in detections]
+        raw_reference_geometries = [({"id": str(row.id), "feature_class": row.feature_class}, to_shape(row.geometry)) for row in references]
+        candidate_geometries = raw_candidate_geometries
+        reference_geometries = raw_reference_geometries
+        run_parameters = run.parameters_json if isinstance(run.parameters_json, dict) else {}
+        manifest_path = DetectionQaService.tile_manifest_path(run_parameters)
+        resolved_settings = get_settings()
+        is_configured_yolo = (
+            run_parameters.get("model_id") == resolved_settings.yolo_model_id
+            or run.model_name == resolved_settings.yolo_model_id
+        )
+        if is_configured_yolo and not manifest_path:
+            raise AppError(
+                code="DETECTION_QA_COVERAGE_UNAVAILABLE",
+                message="Configured YOLO QA requires persisted tile manifest provenance",
+                status_code=422,
+            )
+
+        coverage_summary: dict[str, Any] = {
+            "applied": False,
+            "mode": "unbounded_no_manifest",
+            "manifest_path": None,
+            "tile_count": 0,
+            "source_crs_values": [],
+            "candidate_raw_count": len(raw_candidate_geometries),
+            "candidate_evaluated_count": len(raw_candidate_geometries),
+            "candidate_excluded_outside_count": 0,
+            "candidate_clipped_boundary_count": 0,
+            "reference_raw_count": len(raw_reference_geometries),
+            "reference_evaluated_count": len(raw_reference_geometries),
+            "reference_excluded_outside_count": 0,
+            "reference_clipped_boundary_count": 0,
+        }
+        coverage_warnings: list[str] = []
+        if manifest_path:
+            manifest = DetectionService._load_tile_manifest(manifest_path, resolved_settings.yolo_max_tiles)
+            coverage = DetectionQaService.build_tile_coverage(
+                manifest,
+                manifest_path=manifest_path,
+                expected_dataset_id=run.dataset_id,
+            )
+            candidate_population = DetectionQaService.filter_population(raw_candidate_geometries, coverage)
+            reference_population = DetectionQaService.filter_population(raw_reference_geometries, coverage)
+            candidate_geometries = candidate_population.geometries
+            reference_geometries = reference_population.geometries
+            if not reference_geometries:
+                raise AppError(
+                    code="REFERENCE_FEATURES_OUTSIDE_COVERAGE",
+                    message="Reference dataset has no polygon features inside persisted inference tile coverage",
+                    status_code=422,
+                )
+            coverage_summary = {
+                "applied": True,
+                "mode": "persisted_tile_manifest_union",
+                "manifest_path": coverage.manifest_path,
+                "tile_count": coverage.tile_count,
+                "source_crs_values": list(coverage.source_crs_values),
+                "candidate_raw_count": candidate_population.raw_count,
+                "candidate_evaluated_count": candidate_population.evaluated_count,
+                "candidate_excluded_outside_count": candidate_population.excluded_outside_count,
+                "candidate_clipped_boundary_count": candidate_population.clipped_boundary_count,
+                "reference_raw_count": reference_population.raw_count,
+                "reference_evaluated_count": reference_population.evaluated_count,
+                "reference_excluded_outside_count": reference_population.excluded_outside_count,
+                "reference_clipped_boundary_count": reference_population.clipped_boundary_count,
+            }
+            coverage_warnings.append(
+                "QA populations were clipped to the union of persisted inference tile footprints before matching."
+            )
         evidence = QaService._match_io_u_evidence(
             candidate_geometries,
             reference_geometries,
             iou_threshold,
         )
+        reference_envelopes = [(feature, geometry.envelope) for feature, geometry in reference_geometries]
+        envelope_evidence = QaService._match_io_u_evidence(
+            candidate_geometries,
+            reference_envelopes,
+            iou_threshold,
+        )
+        box_to_footprint_diagnostics = DetectionQaService.box_to_footprint_diagnostics(
+            evidence,
+            envelope_evidence,
+            iou_threshold=iou_threshold,
+        )
         mean_iou = None if not evidence.match_iou_values else sum(evidence.match_iou_values) / len(evidence.match_iou_values)
         precision = evidence.matches / (evidence.matches + evidence.false_positives) if evidence.matches + evidence.false_positives > 0 else None
         recall = evidence.matches / (evidence.matches + evidence.false_negatives) if evidence.matches + evidence.false_negatives > 0 else None
@@ -324,13 +403,16 @@ class DetectionService:
                 "iou_threshold": iou_threshold,
                 "class_name": class_name,
                 "min_confidence": min_confidence,
+                "coverage_policy": coverage_summary["mode"],
             },
             findings={
                 "matches": evidence.matches,
                 "false_positives": evidence.false_positives,
                 "false_negatives": evidence.false_negatives,
-                "warnings": evidence.warnings,
+                "warnings": coverage_warnings + evidence.warnings,
                 "unsupported_geometry": evidence.unsupported,
+                "coverage": coverage_summary,
+                "box_to_footprint_diagnostics": box_to_footprint_diagnostics,
                 "match_evidence": evidence.match_evidence,
                 "false_positive_evidence": evidence.false_positive_evidence,
                 "false_negative_evidence": evidence.false_negative_evidence,
@@ -351,6 +433,8 @@ class DetectionService:
             "reference_dataset_id": str(reference_dataset_id),
             "candidate_feature_count": len(candidate_geometries),
             "reference_feature_count": len(reference_geometries),
+            "candidate_feature_count_raw": len(raw_candidate_geometries),
+            "reference_feature_count_raw": len(raw_reference_geometries),
             "matches": evidence.matches,
             "false_positives": evidence.false_positives,
             "false_negatives": evidence.false_negatives,
@@ -359,7 +443,9 @@ class DetectionService:
             "f1_score": f1_score,
             "mean_iou": mean_iou,
             "iou_threshold": iou_threshold,
-            "warnings": evidence.warnings,
+            "warnings": coverage_warnings + evidence.warnings,
+            "coverage": coverage_summary,
+            "box_to_footprint_diagnostics": box_to_footprint_diagnostics,
             "match_evidence": evidence.match_evidence,
             "false_positive_evidence": evidence.false_positive_evidence,
             "false_negative_evidence": evidence.false_negative_evidence,