test opecv échoué

lib/services/target_detection_service.dart

@@ -1,8 +1,10 @@
 import 'dart:math' as math;
 import '../data/models/target_type.dart';
 import 'image_processing_service.dart';
+import 'opencv_impact_detection_service.dart';
 
 export 'image_processing_service.dart' show ImpactDetectionSettings, ReferenceImpact, ImpactCharacteristics;
+export 'opencv_impact_detection_service.dart' show OpenCVDetectionSettings, OpenCVDetectedImpact;
 
 class TargetDetectionResult {
   final double centerX; // Relative (0-1)
@@ -49,10 +51,13 @@ class DetectedImpactResult {
 
 class TargetDetectionService {
   final ImageProcessingService _imageProcessingService;
+  final OpenCVImpactDetectionService _opencvService;
 
   TargetDetectionService({
     ImageProcessingService? imageProcessingService,
-  }) : _imageProcessingService = imageProcessingService ?? ImageProcessingService();
+    OpenCVImpactDetectionService? opencvService,
+  })  : _imageProcessingService = imageProcessingService ?? ImageProcessingService(),
+        _opencvService = opencvService ?? OpenCVImpactDetectionService();
 
   /// Detect target and impacts from an image file
   TargetDetectionResult detectTarget(
@@ -254,4 +259,88 @@ class TargetDetectionService {
       return [];
     }
   }
+
+  /// Détecte les impacts en utilisant OpenCV (Hough Circles + Contours)
+  ///
+  /// Cette méthode utilise les algorithmes OpenCV pour une détection plus robuste:
+  /// - Transformation de Hough pour détecter les cercles
+  /// - Analyse de contours avec filtrage par circularité
+  List<DetectedImpactResult> detectImpactsWithOpenCV(
+    String imagePath,
+    TargetType targetType,
+    double centerX,
+    double centerY,
+    double radius,
+    int ringCount, {
+    OpenCVDetectionSettings? settings,
+  }) {
+    try {
+      final impacts = _opencvService.detectImpacts(
+        imagePath,
+        settings: settings ?? const OpenCVDetectionSettings(),
+      );
+
+      return impacts.map((impact) {
+        final score = targetType == TargetType.concentric
+            ? _calculateConcentricScoreWithRings(
+                impact.x, impact.y, centerX, centerY, radius, ringCount)
+            : _calculateSilhouetteScore(impact.x, impact.y, centerX, centerY);
+
+        return DetectedImpactResult(
+          x: impact.x,
+          y: impact.y,
+          radius: impact.radius,
+          suggestedScore: score,
+        );
+      }).toList();
+    } catch (e) {
+      print('Erreur détection OpenCV: $e');
+      return [];
+    }
+  }
+
+  /// Détecte les impacts avec OpenCV en utilisant des références
+  ///
+  /// Analyse les impacts de référence pour apprendre leurs caractéristiques
+  /// puis détecte les impacts similaires dans l'image.
+  List<DetectedImpactResult> detectImpactsWithOpenCVFromReferences(
+    String imagePath,
+    TargetType targetType,
+    double centerX,
+    double centerY,
+    double radius,
+    int ringCount,
+    List<ReferenceImpact> references, {
+    double tolerance = 2.0,
+  }) {
+    try {
+      // Convertir les références au format OpenCV
+      final refPoints = references
+          .map((r) => (x: r.x, y: r.y))
+          .toList();
+
+      final impacts = _opencvService.detectFromReferences(
+        imagePath,
+        refPoints,
+        tolerance: tolerance,
+      );
+
+      return impacts.map((impact) {
+        final score = targetType == TargetType.concentric
+            ? _calculateConcentricScoreWithRings(
+                impact.x, impact.y, centerX, centerY, radius, ringCount)
+            : _calculateSilhouetteScore(impact.x, impact.y, centerX, centerY);
+
+        return DetectedImpactResult(
+          x: impact.x,
+          y: impact.y,
+          radius: impact.radius,
+          suggestedScore: score,
+        );
+      }).toList();
+    } catch (e) {
+      print('Erreur détection OpenCV depuis références: $e');
+      return [];
+    }
+  }
 }