nettoyage du code avec cunning

lib/services/opencv_target_service.dart

@@ -0,0 +1,155 @@
+import 'dart:math' as math;
+import 'package:opencv_dart/opencv_dart.dart' as cv;
+
+class TargetDetectionResult {
+  final double centerX;
+  final double centerY;
+  final double radius;
+  final bool success;
+
+  TargetDetectionResult({
+    required this.centerX,
+    required this.centerY,
+    required this.radius,
+    this.success = true,
+  });
+
+  factory TargetDetectionResult.failure() {
+    return TargetDetectionResult(
+      centerX: 0.5,
+      centerY: 0.5,
+      radius: 0.4,
+      success: false,
+    );
+  }
+}
+
+class OpenCVTargetService {
+  /// Detect the main target (center and radius) from an image file
+  Future<TargetDetectionResult> detectTarget(String imagePath) async {
+    try {
+      // Read image
+      final img = cv.imread(imagePath, flags: cv.IMREAD_COLOR);
+      if (img.isEmpty) {
+        return TargetDetectionResult.failure();
+      }
+
+      // Convert to grayscale
+      final gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY);
+
+      // Apply Gaussian blur to reduce noise
+      final blurred = cv.gaussianBlur(gray, (9, 9), 2, sigmaY: 2);
+
+      // Detect circles using Hough Transform
+      // Parameters need to be tuned for the specific target type
+      final circles = cv.HoughCircles(
+        blurred,
+        cv.HOUGH_GRADIENT,
+        1, // dp: Inverse ratio of the accumulator resolution to the image resolution
+        (img.rows / 8)
+            .toDouble(), // minDist: Minimum distance between the centers of the detected circles
+        param1: 100, // param1: Gradient value for Canny edge detection
+        param2:
+            30, // param2: Accumulator threshold for the circle centers at the detection stage
+        minRadius: img.cols ~/ 20, // minRadius
+        maxRadius: img.cols ~/ 2, // maxRadius
+      );
+
+      // HoughCircles returns a Mat in opencv_dart? Or a specific object?
+      // Checking common bindings: usually returns a Mat (1, N, 3) of floats.
+      // If circles is empty or null, return failure.
+
+      if (circles.isEmpty) {
+        // Try with different parameters if first attempt fails (more lenient)
+        final looseCircles = cv.HoughCircles(
+          blurred,
+          cv.HOUGH_GRADIENT,
+          1,
+          (img.rows / 8).toDouble(),
+          param1: 50,
+          param2: 20,
+          minRadius: img.cols ~/ 20,
+          maxRadius: img.cols ~/ 2,
+        );
+
+        if (looseCircles.isEmpty) {
+          return TargetDetectionResult.failure();
+        }
+        return _findBestCircle(looseCircles, img.cols, img.rows);
+      }
+
+      return _findBestCircle(circles, img.cols, img.rows);
+    } catch (e) {
+      // print('Error detecting target with OpenCV: $e');
+      return TargetDetectionResult.failure();
+    }
+  }
+
+  TargetDetectionResult _findBestCircle(cv.Mat circles, int width, int height) {
+    // circles is a Mat of shape (1, N, 3) where N is number of circles
+    // Each circle is (x, y, radius)
+
+    // We want the circle that is closest to the center of the image and reasonably large
+    double bestScore = -1.0;
+    double bestX = 0.5;
+    double bestY = 0.5;
+    double bestRadius = 0.4;
+
+    // The shape is typically (1, N, 3) for HoughCircles
+    // We need to access the data.
+    // Assuming we can iterate.
+    // In opencv_dart 1.0+, Mat might not be directly iterable like a list.
+    // We can use circles.at<Vec3f>(0, i) if available or similar.
+    // Or we might need to interpret the memory.
+
+    // For now, let's assume a simplified access pattern or that we can get a list.
+    // If this fails to compile, we will fix it based on the error.
+
+    // Attempting to access knowing standard layout:
+    // circles.rows is 1, circles.cols is N.
+
+    final int numCircles = circles.cols;
+
+    for (int i = 0; i < numCircles; i++) {
+      // Use the generic 'at' or specific getter if known.
+      // Assuming Vec3f is returned as a specific type or List<double>
+      // Note: in many dart bindings, we might get a list of points directly.
+      // But HoughCircles typically returns Mat.
+
+      // Let's try to use `at<cv.Vec3f>(0, i)` which is common in C++ and some bindings.
+      // If not, we might need `ptr` access.
+
+      final vec = circles.at<cv.Vec3f>(0, i);
+      final double x = vec.val1;
+      final double y = vec.val2;
+      final double r = vec.val3;
+
+      final relX = x / width;
+      final relY = y / height;
+      final relR = r / math.min(width, height);
+
+      // Score based on centrality and size
+      final distFromCenter = math.sqrt(
+        math.pow(relX - 0.5, 2) + math.pow(relY - 0.5, 2),
+      );
+      final sizeScore =
+          relR; // Larger is usually better for the main target outer ring
+
+      // We penalize distance from center
+      final score = sizeScore - (distFromCenter * 0.5);
+
+      if (score > bestScore) {
+        bestScore = score;
+        bestX = relX;
+        bestY = relY;
+        bestRadius = relR;
+      }
+    }
+
+    return TargetDetectionResult(
+      centerX: bestX,
+      centerY: bestY,
+      radius: bestRadius,
+    );
+  }
+}