fix: bound detection QA to inference coverage

backend/app/services/detection_service.py

@@ -9,6 +9,7 @@ from typing import Type
 
 from geoalchemy2.shape import from_shape, to_shape
 from shapely.geometry import mapping, shape
+from sqlalchemy import func
 
 from app.core.config import Settings, get_settings
 from app.core.errors import AppError
@@ -288,18 +289,8 @@ class DetectionService:
             class_name=class_name,
             min_confidence=min_confidence,
         )
-        references = db.query(VectorFeature).filter(VectorFeature.dataset_id == reference_dataset_id).all()
-        if not references:
-            raise AppError(
-                code="REFERENCE_FEATURES_NOT_FOUND",
-                message="Reference dataset has no persisted vector features for QA",
-                status_code=422,
-            )
-
         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()
@@ -314,6 +305,34 @@ class DetectionService:
                 status_code=422,
             )
 
+        coverage = None
+        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,
+            )
+
+        reference_query = db.query(VectorFeature).filter(VectorFeature.dataset_id == reference_dataset_id)
+        if coverage is not None and hasattr(reference_query, "count"):
+            reference_raw_count = reference_query.count()
+            references = reference_query.filter(
+                func.ST_Intersects(VectorFeature.geometry, from_shape(coverage.geometry, srid=4326))
+            ).all()
+        else:
+            references = reference_query.all()
+            reference_raw_count = len(references)
+        if reference_raw_count == 0:
+            raise AppError(
+                code="REFERENCE_FEATURES_NOT_FOUND",
+                message="Reference dataset has no persisted vector features for QA",
+                status_code=422,
+            )
+
+        raw_reference_geometries = [({"id": str(row.id), "feature_class": row.feature_class}, to_shape(row.geometry)) for row in references]
+        reference_geometries = raw_reference_geometries
+
         coverage_summary: dict[str, Any] = {
             "applied": False,
             "mode": "unbounded_no_manifest",
@@ -324,21 +343,19 @@ class DetectionService:
             "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_raw_count": reference_raw_count,
             "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,
-            )
+        if coverage is not None:
             candidate_population = DetectionQaService.filter_population(raw_candidate_geometries, coverage)
-            reference_population = DetectionQaService.filter_population(raw_reference_geometries, coverage)
+            reference_population = DetectionQaService.filter_population(
+                raw_reference_geometries,
+                coverage,
+                raw_count=reference_raw_count,
+            )
             candidate_geometries = candidate_population.geometries
             reference_geometries = reference_population.geometries
             if not reference_geometries:
@@ -434,7 +451,7 @@ class DetectionService:
             "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),
+            "reference_feature_count_raw": reference_raw_count,
             "matches": evidence.matches,
             "false_positives": evidence.false_positives,
             "false_negatives": evidence.false_negatives,