test opecv échoué

lib/features/analysis/analysis_provider.dart

@@ -254,6 +254,130 @@ class AnalysisProvider extends ChangeNotifier {
     return detectedImpacts.length;
   }
 
+  /// Auto-detect impacts using OpenCV (Hough Circles + Contours)
+  ///
+  /// NOTE: OpenCV est actuellement désactivé sur Windows en raison de problèmes
+  /// de compilation. Cette méthode retourne 0 (aucun impact détecté).
+  /// Utiliser autoDetectImpacts() à la place.
+  ///
+  /// 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é
+  Future<int> autoDetectImpactsWithOpenCV({
+    double cannyThreshold1 = 50,
+    double cannyThreshold2 = 150,
+    double minDist = 20,
+    double param1 = 100,
+    double param2 = 30,
+    int minRadius = 5,
+    int maxRadius = 50,
+    int blurSize = 5,
+    bool useContourDetection = true,
+    double minCircularity = 0.6,
+    double minContourArea = 50,
+    double maxContourArea = 5000,
+    bool clearExisting = false,
+  }) async {
+    if (_imagePath == null || _targetType == null) return 0;
+
+    final settings = OpenCVDetectionSettings(
+      cannyThreshold1: cannyThreshold1,
+      cannyThreshold2: cannyThreshold2,
+      minDist: minDist,
+      param1: param1,
+      param2: param2,
+      minRadius: minRadius,
+      maxRadius: maxRadius,
+      blurSize: blurSize,
+      useContourDetection: useContourDetection,
+      minCircularity: minCircularity,
+      minContourArea: minContourArea,
+      maxContourArea: maxContourArea,
+    );
+
+    final detectedImpacts = _detectionService.detectImpactsWithOpenCV(
+      _imagePath!,
+      _targetType!,
+      _targetCenterX,
+      _targetCenterY,
+      _targetRadius,
+      _ringCount,
+      settings: settings,
+    );
+
+    if (clearExisting) {
+      _shots.clear();
+    }
+
+    // Add detected impacts as shots
+    for (final impact in detectedImpacts) {
+      final score = _calculateShotScore(impact.x, impact.y);
+      final shot = Shot(
+        id: _uuid.v4(),
+        x: impact.x,
+        y: impact.y,
+        score: score,
+        sessionId: '',
+      );
+      _shots.add(shot);
+    }
+
+    _recalculateScores();
+    _recalculateGrouping();
+    notifyListeners();
+
+    return detectedImpacts.length;
+  }
+
+  /// Detect impacts with OpenCV using reference points
+  Future<int> detectFromReferencesWithOpenCV({
+    double tolerance = 2.0,
+    bool clearExisting = false,
+  }) async {
+    if (_imagePath == null || _targetType == null || _referenceImpacts.length < 2) {
+      return 0;
+    }
+
+    // Convertir les références
+    final references = _referenceImpacts
+        .map((shot) => ReferenceImpact(x: shot.x, y: shot.y))
+        .toList();
+
+    final detectedImpacts = _detectionService.detectImpactsWithOpenCVFromReferences(
+      _imagePath!,
+      _targetType!,
+      _targetCenterX,
+      _targetCenterY,
+      _targetRadius,
+      _ringCount,
+      references,
+      tolerance: tolerance,
+    );
+
+    if (clearExisting) {
+      _shots.clear();
+    }
+
+    // Add detected impacts as shots
+    for (final impact in detectedImpacts) {
+      final score = _calculateShotScore(impact.x, impact.y);
+      final shot = Shot(
+        id: _uuid.v4(),
+        x: impact.x,
+        y: impact.y,
+        score: score,
+        sessionId: '',
+      );
+      _shots.add(shot);
+    }
+
+    _recalculateScores();
+    _recalculateGrouping();
+    notifyListeners();
+
+    return detectedImpacts.length;
+  }
+
   /// Add a reference impact for calibrated detection
   void addReferenceImpact(double x, double y) {
     final score = _calculateShotScore(x, y);
@@ -405,6 +529,45 @@ class AnalysisProvider extends ChangeNotifier {
     }
   }
 
+
+/* version deux a tester*/
+  /// Calcule ET applique la correction pour un feedback immédiat
+  Future<void> calculateAndApplyDistortion() async {
+    // 1. Calcul des paramètres (votre code actuel)
+    _distortionParams = _distortionService.calculateDistortionFromCalibration(
+      targetCenterX: _targetCenterX,
+      targetCenterY: _targetCenterY,
+      targetRadius: _targetRadius,
+      imageAspectRatio: _imageAspectRatio,
+    );
+    
+    // 2. Vérification si une correction est réellement nécessaire
+    if (_distortionParams != null && _distortionParams!.needsCorrection) {
+      // 3. Application immédiate de la transformation (méthode asynchrone)
+      await applyDistortionCorrection(); 
+    } else {
+      notifyListeners(); // On prévient quand même si pas de correction
+    }
+  }
+
+  Future<void> runFullDistortionWorkflow() async {
+    _state = AnalysisState.loading; // Affiche un spinner sur votre UI
+    notifyListeners();
+
+    try {
+      calculateDistortion(); // Calcule les paramètres
+      await applyDistortionCorrection(); // Génère le fichier corrigé
+      _distortionCorrectionEnabled = true; // Active l'affichage
+      _state = AnalysisState.success;
+    } catch (e) {
+      _errorMessage = "Erreur de rendu : $e";
+      _state = AnalysisState.error;
+    } finally {
+      notifyListeners();
+    }
+  }
+/* fin section deux a tester*/
+
   int _calculateShotScore(double x, double y) {
     if (_targetType == TargetType.concentric) {
       return _scoreCalculatorService.calculateConcentricScore(