From 3b2172e3eca10c67294c926394704fa47ab7dddf Mon Sep 17 00:00:00 2001
From: qguillaume <quesnel.guillaume.j@gmail.com>
Date: Mon, 15 Jun 2026 17:19:47 +0200
Subject: [PATCH] feat: integration mlkit Document Scanner pour la prise de
 photo

Remplace la camera maison par le scanner de documents Google ML Kit
qui detecte les bords de la cible et la redresse de face automatiquement
(mode base = sans filtre couleur, pour conserver les couleurs reelles).

- nouveau service DocumentScannerService (scanTarget)
- capture_screen branche sur le scanner mlkit, reglages galerie 1280/q75 conserves
- AndroidManifest: meta-data com.google.mlkit.vision.DEPENDENCIES=docscanner

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 android/app/src/main/AndroidManifest.xml   |   4 +
 lib/features/capture/capture_screen.dart   | 981 +++------------------
 lib/services/document_scanner_service.dart |  54 ++
 3 files changed, 162 insertions(+), 877 deletions(-)
 create mode 100644 lib/services/document_scanner_service.dart

diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml
index f8435084..f837ef63 100644
--- a/android/app/src/main/AndroidManifest.xml
+++ b/android/app/src/main/AndroidManifest.xml
@@ -37,6 +37,10 @@
         <meta-data
             android:name="flutterEmbedding"
             android:value="2" />
+        <!-- ML Kit Document Scanner : télécharge le module de scan de la cible -->
+        <meta-data
+            android:name="com.google.mlkit.vision.DEPENDENCIES"
+            android:value="docscanner" />
     </application>
     <!-- Required to query activities that can process text, see:
          https://developer.android.com/training/package-visibility and
diff --git a/lib/features/capture/capture_screen.dart b/lib/features/capture/capture_screen.dart
index 3626b331..589df897 100644
--- a/lib/features/capture/capture_screen.dart
+++ b/lib/features/capture/capture_screen.dart
@@ -1,12 +1,8 @@
 import 'dart:io';
-import 'dart:math' as math;
-import 'dart:async';
-import 'dart:isolate';
 import 'package:flutter/material.dart';
 import 'package:image_picker/image_picker.dart';
 import 'package:permission_handler/permission_handler.dart';
 import 'package:device_info_plus/device_info_plus.dart';
-import 'package:camera/camera.dart';
 
 import 'package:provider/provider.dart';
 import '../../core/constants/app_constants.dart';
@@ -15,11 +11,7 @@ import '../../data/models/target_type.dart';
 import '../crop/crop_screen.dart';
 import '../session/session_provider.dart';
 import 'widgets/image_source_button.dart';
-import '../../services/image_crop_service.dart';
-import '../../services/opencv_target_service.dart';
-import '../../services/parallelism_service.dart'; // NOUVEAU
-import 'package:image/image.dart' as img;
-import 'package:path_provider/path_provider.dart';
+import '../../services/document_scanner_service.dart'; // Scanner ML Kit : redresse la cible de face
 
 class CaptureScreen extends StatefulWidget {
   const CaptureScreen({super.key});
@@ -28,320 +20,102 @@ class CaptureScreen extends StatefulWidget {
   State<CaptureScreen> createState() => _CaptureScreenState();
 }
 
-class _CaptureScreenState extends State<CaptureScreen>
-    with SingleTickerProviderStateMixin {
+class _CaptureScreenState extends State<CaptureScreen> {
   final ImagePicker _picker = ImagePicker();
-  final ImageCropService _cropService = ImageCropService();
   final TargetType _selectedType = TargetType.concentric;
-  final OpenCVTargetService _opencvService = OpenCVTargetService();
 
-  // NOUVEAU : Service IMU de parallélisme
-  // L'angle passe à l'ORANGE dès 3° d'inclinaison (pitch ou roll).
-  // Petite hystérésis : il faut revenir sous 2° pour repasser au vert,
-  // ce qui évite le clignotement quand la main tremble autour de 3°.
-  final ParallelismService _parallelismService = ParallelismService(
-    alignThreshold: 2.0,    // retour au vert : worstAngle ≤ 2°
-    misalignThreshold: 3.0, // passage à l'orange : worstAngle > 3°
-  );
+  // Scanner de documents Google ML Kit (redresse la cible de face automatiquement)
+  final DocumentScannerService _docScanner = DocumentScannerService();
 
   String? _selectedImagePath;
   bool _isLoading = false;
-  bool _isCapturing = false; // garde anti-double-capture pendant le traitement
-  // Chemin de la photo tout juste capturée, affichée FIGÉE pendant le
-  // traitement (downscale). Tant qu'il est null, la capture physique est
-  // encore en cours → l'utilisateur doit rester immobile. Une fois rempli,
-  // la photo est prise et l'utilisateur peut bouger.
-  String? _capturedPreviewPath;
-
-  // Caméra live
-  CameraController? _cameraController;
-  List<CameraDescription>? _cameras;
-  bool _isCameraInitialized = false;
-  bool _showLiveCamera = false;
-
-  // Animation pulsation du viseur
-  late AnimationController _scanAnimationController;
-  late Animation<double> _scanAnimation;
-
-  // Détection OpenCV (cible circulaire) — on garde le résultat COMPLET
-  bool? _alignmentStatus;
-  TargetDetectionResult? _targetResult; // NOUVEAU : centre + rayon de la cible
-  Timer? _detectionTimer;
-  bool _isAnalyzingFrame = false;
-
-  // NOUVEAU : Données IMU en temps réel
-  ParallelismData? _parallelismData;
-  StreamSubscription<ParallelismData>? _parallelismSubscription;
 
+  // ─────────────────────────────────────────────────────────────────────────
+  // Build principal
+  // ─────────────────────────────────────────────────────────────────────────
   @override
-  void initState() {
-    super.initState();
-    _scanAnimationController = AnimationController(
-      duration: const Duration(seconds: 2),
-      vsync: this,
-    )..repeat(reverse: true);
+  Widget build(BuildContext context) {
+    final sessionProvider = context.watch<SessionProvider>();
+    final title = sessionProvider.isSessionActive
+        ? 'Cible ${sessionProvider.targetCount + 1}'
+        : 'Source';
 
-    _scanAnimation = Tween<double>(begin: 0.8, end: 1.0).animate(
-      CurvedAnimation(parent: _scanAnimationController, curve: Curves.easeInOut),
+    return Scaffold(
+      appBar: AppBar(title: Text(title)),
+      body: SingleChildScrollView(
+        padding: const EdgeInsets.all(AppConstants.defaultPadding),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: [
+            const SizedBox(height: AppConstants.largePadding),
+            _buildSectionTitle('Source de l\'Image'),
+            const SizedBox(height: 12),
+            Row(
+              children: [
+                Expanded(
+                  child: ImageSourceButton(
+                    icon: Icons.document_scanner,
+                    label: 'Scanner',
+                    onPressed: _isLoading ? null : _scanWithDocumentScanner,
+                  ),
+                ),
+                const SizedBox(width: 12),
+                Expanded(
+                  child: ImageSourceButton(
+                    icon: Icons.photo_library,
+                    label: 'Galerie',
+                    onPressed: _isLoading ? null : _handleGallerySelection,
+                  ),
+                ),
+              ],
+            ),
+            const SizedBox(height: AppConstants.largePadding),
+            if (_isLoading)
+              const Center(
+                child: Padding(
+                  padding: EdgeInsets.all(32),
+                  child: CircularProgressIndicator(),
+                ),
+              )
+            else
+              _buildGuide(),
+          ],
+        ),
+      ),
     );
   }
 
-  @override
-  void dispose() {
-    _cameraController?.dispose();
-    _scanAnimationController.dispose();
-    _detectionTimer?.cancel();
-    _parallelismSubscription?.cancel(); // NOUVEAU
-    _parallelismService.dispose();      // NOUVEAU
-    super.dispose();
-  }
-
   // ─────────────────────────────────────────────────────────────────────────
-  // NOUVEAU : Démarre l'écoute IMU et met à jour l'UI en temps réel
+  // Déclic → lance le scanner de documents Google ML Kit qui redresse
+  // automatiquement la cible (feuille rectangulaire) de face.
   // ─────────────────────────────────────────────────────────────────────────
-  void _startParallelismDetection() {
-    _parallelismSubscription?.cancel();
-    _parallelismService.start();
-
-    _parallelismSubscription = _parallelismService.stream.listen((data) {
-      if (mounted && _showLiveCamera) {
-        setState(() {
-          _parallelismData = data;
-        });
-      }
-    });
-  }
-
-  void _stopParallelismDetection() {
-    _parallelismSubscription?.cancel();
-    _parallelismSubscription = null;
-    _parallelismService.stop();
-    _parallelismData = null;
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Calcule la couleur et le message depuis l'IMU + la détection de cible
-  // ─────────────────────────────────────────────────────────────────────────
-
-  /// La cible circulaire est-elle détectée et raisonnablement cadrée ?
-  bool get _targetReady {
-    final t = _targetResult;
-    if (t == null || !t.success) return false;
-    final bool centered =
-        t.centerX > 0.15 && t.centerX < 0.85 && t.centerY > 0.15 && t.centerY < 0.85;
-    final bool bigEnough = t.radius > 0.12;
-    return centered && bigEnough;
-  }
-
-  /// Couleur du cadre : dépend UNIQUEMENT du parallélisme IMU.
-  /// (La détection de cible sert seulement à dessiner le cercle, elle ne
-  ///  bloque jamais le passage au vert.)
-  Color get _frameColor {
-    final bool imuAligned =
-        _parallelismData == null || _parallelismData!.isAligned;
-    return imuAligned ? const Color(0xFF00FF00) : Colors.orange;
-  }
-
-  /// Message d'aide selon le parallélisme IMU.
-  String get _alignmentMessage {
-    if (_parallelismData == null ||
-        _parallelismData!.status == ParallelismStatus.unknown) {
-      return 'ALIGNEZ LA CIBLE DANS LE CADRE';
-    }
-
-    // Aligné → message de validation (avec bonus si la cible est détectée)
-    if (_parallelismData!.isAligned) {
-      return _targetReady
-          ? 'PARFAIT — CIBLE DÉTECTÉE, PRÊT'
-          : 'PARALLÈLE OK — PRÊT À PHOTOGRAPHIER';
-    }
-
-    // Mal aligné → message directif selon l'axe le plus dévié
-    final double pitch = _parallelismData!.pitchDegrees;
-    final double roll = _parallelismData!.rollDegrees;
-
-    if (pitch.abs() >= roll.abs()) {
-      return pitch > 0
-          ? 'INCLINEZ VERS L\'AVANT (${pitch.toStringAsFixed(1)}°)'
-          : 'INCLINEZ VERS L\'ARRIÈRE (${(-pitch).toStringAsFixed(1)}°)';
-    } else {
-      return roll > 0
-          ? 'INCLINEZ VERS LA GAUCHE (${roll.toStringAsFixed(1)}°)'
-          : 'INCLINEZ VERS LA DROITE (${(-roll).toStringAsFixed(1)}°)';
-    }
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Initialisation de la caméra (inchangée, sauf ajout IMU)
-  // ─────────────────────────────────────────────────────────────────────────
-  Future<void> _initLiveCamera() async {
-    final status = await Permission.camera.request();
-    if (!status.isGranted) {
-      if (mounted) {
-        ScaffoldMessenger.of(context).showSnackBar(
-          const SnackBar(content: Text('Accès à l\'appareil photo requis')),
-        );
-      }
-      return;
-    }
-
+  Future<void> _scanWithDocumentScanner() async {
     setState(() => _isLoading = true);
     try {
-      if (_cameraController != null) {
-        await _cameraController!.dispose();
-        _cameraController = null;
-        _isCameraInitialized = false;
+      final result = await _docScanner.scanTarget();
+
+      if (!result.success) {
+        // L'utilisateur a annulé le scan : on ne fait rien de plus.
+        if (mounted) setState(() => _isLoading = false);
+        return;
       }
 
-      _cameras = await availableCameras();
-      if (_cameras != null && _cameras!.isNotEmpty) {
-        // PERF : on capture en `veryHigh` (2160p) et non en `max`. Le pipeline
-        // redimensionne ensuite tout à 1080 px max → la résolution `max`
-        // (12–48 MP) ne servait à rien et rallongeait fortement le décodage
-        // post-capture (« délai de quelques secondes »). `veryHigh` reste très
-        // au-dessus du 1080 px final : aucune perte de qualité, mais décodage
-        // bien plus rapide.
-        _cameraController = CameraController(
-          _cameras![0],
-          ResolutionPreset.veryHigh,
-          enableAudio: false,
-          imageFormatGroup: ImageFormatGroup.jpeg,
+      setState(() {
+        _selectedImagePath = result.imagePath;
+      });
+
+      _analyzeImage();
+    } catch (e) {
+      debugPrint('Erreur scanner document: $e');
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          const SnackBar(
+            content: Text('Le scan a échoué. Réessayez.'),
+          ),
         );
-
-        await _cameraController!.initialize();
-
-        setState(() {
-          _isCameraInitialized = true;
-          _showLiveCamera = true;
-          _alignmentStatus = null;
-          _targetResult = null; // reset détection cible
-          _parallelismData = null; // NOUVEAU : reset IMU
-        });
-
-        _startAlignmentDetection();
-        _startParallelismDetection(); // NOUVEAU
       }
-    } catch (e) {
-      debugPrint('Erreur caméra: $e');
     } finally {
-      setState(() => _isLoading = false);
-    }
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Détection OpenCV périodique (inchangée)
-  // ─────────────────────────────────────────────────────────────────────────
-  void _startAlignmentDetection() {
-    _detectionTimer?.cancel();
-    _detectionTimer = null;
-
-    DateTime? _lastAnalysis;
-
-    _cameraController!.startImageStream((CameraImage cameraImage) async {
-      if (_isAnalyzingFrame) return;
-      final now = DateTime.now();
-      // Cadence ~1 s : assez réactif pour suivre la cible sans saturer le CPU.
-      if (_lastAnalysis != null &&
-          now.difference(_lastAnalysis!).inMilliseconds < 1000) return;
-      _lastAnalysis = now;
-      _isAnalyzingFrame = true;
-
-      try {
-        final tempDir = await getTemporaryDirectory();
-        final tempPath = '${tempDir.path}/frame_analysis.jpg';
-
-        final img.Image? converted = _convertCameraImage(cameraImage);
-        if (converted == null) {
-          _isAnalyzingFrame = false;
-          return;
-        }
-
-        // PERF : qualité 50 pour la frame d'analyse temps réel (jetable)
-        await File(tempPath).writeAsBytes(img.encodeJpg(converted, quality: 50));
-
-        final result = await _opencvService.detectTarget(tempPath);
-
-        try {
-          await File(tempPath).delete();
-        } catch (_) {}
-
-        if (mounted && _showLiveCamera) {
-          setState(() {
-            // On garde le résultat complet pour dessiner le cercle.
-            _targetResult = result.success ? result : null;
-
-            if (!result.success) {
-              _alignmentStatus = null;
-            } else {
-              final bool isCentered =
-                  result.centerX > 0.25 && result.centerX < 0.75 &&
-                      result.centerY > 0.25 && result.centerY < 0.75;
-              final bool isSizedCorrectly = result.radius > 0.15;
-              _alignmentStatus = isCentered && isSizedCorrectly;
-            }
-          });
-        }
-      } catch (e) {
-        debugPrint('Erreur analyse frame: $e');
-      } finally {
-        _isAnalyzingFrame = false;
-      }
-    });
-  }
-
-  void _stopAlignmentDetection() {
-    _detectionTimer?.cancel();
-    _detectionTimer = null;
-    try {
-      if (_cameraController != null &&
-          _cameraController!.value.isStreamingImages) {
-        _cameraController!.stopImageStream();
-      }
-    } catch (_) {}
-    _alignmentStatus = null;
-    _targetResult = null;
-  }
-
-  img.Image? _convertCameraImage(CameraImage cameraImage) {
-    try {
-      final int width = cameraImage.width;
-      final int height = cameraImage.height;
-      final int targetW = width ~/ 2;
-      final int targetH = height ~/ 2;
-
-      final yPlane = cameraImage.planes[0];
-      final uPlane = cameraImage.planes[1];
-      final vPlane = cameraImage.planes[2];
-
-      final image = img.Image(width: targetW, height: targetH);
-
-      for (int y = 0; y < targetH; y++) {
-        for (int x = 0; x < targetW; x++) {
-          final int srcX = x * 2;
-          final int srcY = y * 2;
-
-          final int yIndex = srcY * yPlane.bytesPerRow + srcX;
-          final int uvIndex = (srcY ~/ 2) * uPlane.bytesPerRow +
-              (srcX ~/ 2) * uPlane.bytesPerPixel!;
-
-          final int yVal = yPlane.bytes[yIndex];
-          final int uVal = uPlane.bytes[uvIndex] - 128;
-          final int vVal = vPlane.bytes[uvIndex] - 128;
-
-          final int r = (yVal + 1.402 * vVal).clamp(0, 255).toInt();
-          final int g = (yVal - 0.344136 * uVal - 0.714136 * vVal)
-              .clamp(0, 255)
-              .toInt();
-          final int b = (yVal + 1.772 * uVal).clamp(0, 255).toInt();
-
-          image.setPixelRgb(x, y, r, g, b);
-        }
-      }
-
-      return image;
-    } catch (e) {
-      debugPrint('Erreur conversion frame: $e');
-      return null;
+      if (mounted) setState(() => _isLoading = false);
     }
   }
 
@@ -398,555 +172,45 @@ class _CaptureScreenState extends State<CaptureScreen>
     );
   }
 
-  // ─────────────────────────────────────────────────────────────────────────
-  // Build principal
-  // ─────────────────────────────────────────────────────────────────────────
-  @override
-  Widget build(BuildContext context) {
-    final sessionProvider = context.watch<SessionProvider>();
-    final title = sessionProvider.isSessionActive
-        ? 'Cible ${sessionProvider.targetCount + 1}'
-        : 'Source';
-
-    if (_showLiveCamera &&
-        _cameraController != null &&
-        _cameraController!.value.isInitialized) {
-      return _buildLiveCameraView();
-    }
-
-    return Scaffold(
-      appBar: AppBar(title: Text(title)),
-      body: SingleChildScrollView(
-        padding: const EdgeInsets.all(AppConstants.defaultPadding),
-        child: Column(
-          crossAxisAlignment: CrossAxisAlignment.stretch,
-          children: [
-            const SizedBox(height: AppConstants.largePadding),
-            _buildSectionTitle('Source de l\'Image'),
-            const SizedBox(height: 12),
-            Row(
-              children: [
-                Expanded(
-                  child: ImageSourceButton(
-                    icon: Icons.camera_alt,
-                    label: 'Scanner',
-                    onPressed: _isLoading ? null : _initLiveCamera,
-                  ),
-                ),
-                const SizedBox(width: 12),
-                Expanded(
-                  child: ImageSourceButton(
-                    icon: Icons.photo_library,
-                    label: 'Galerie',
-                    onPressed: _isLoading ? null : _handleGallerySelection,
-                  ),
-                ),
-              ],
-            ),
-            const SizedBox(height: AppConstants.largePadding),
-            if (_isLoading)
-              const Center(
-                child: Padding(
-                  padding: EdgeInsets.all(32),
-                  child: CircularProgressIndicator(),
-                ),
-              )
-            else
-              _buildGuide(),
-          ],
-        ),
-      ),
-    );
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Vue caméra live — MODIFIÉE pour utiliser les données IMU
-  // ─────────────────────────────────────────────────────────────────────────
-  Widget _buildLiveCameraView() {
-    // Priorité : IMU (parallélisme physique) prime sur OpenCV (centrage)
-    // Si l'IMU dit "mal aligné" → orange, sinon → vert
-    final Color frameColor = _frameColor;
-    final String alignmentMessage = _alignmentMessage;
-
-    return Scaffold(
-      backgroundColor: Colors.black,
-      body: Stack(
-        fit: StackFit.expand,
-        children: [
-          // 1. Flux vidéo caméra
-          // On utilise le ratio RÉEL du capteur (et non un 3/4 codé en dur) :
-          // sinon l'aperçu est étiré dès que la résolution choisie n'est pas
-          // en 4:3 (ex. veryHigh en 16:9 écrasait la cible en rectangle).
-          // `value.aspectRatio` est le ratio paysage du flux → on l'inverse
-          // pour l'affichage portrait.
-          Center(
-            child: AspectRatio(
-              aspectRatio: 1 / _cameraController!.value.aspectRatio,
-              child: CameraPreview(_cameraController!),
-            ),
-          ),
-
-          // 2. Coins du cadre et mire centrale (sans le cadre rectangulaire)
-          Center(
-            child: SizedBox(
-              width: MediaQuery.of(context).size.width * 0.85,
-              height: MediaQuery.of(context).size.width * 0.85,
-              child: Stack(
-                children: [
-                  _buildCameraCorner(TopLeft: true, color: frameColor),
-                  _buildCameraCorner(TopRight: true, color: frameColor),
-                  _buildCameraCorner(BottomLeft: true, color: frameColor),
-                  _buildCameraCorner(BottomRight: true, color: frameColor),
-                  Center(
-                    child: Container(
-                      width: 24,
-                      height: 24,
-                      decoration: BoxDecoration(
-                        shape: BoxShape.circle,
-                        border: Border.all(color: frameColor, width: 1.2),
-                      ),
-                      child: Stack(
-                        children: [
-                          Center(
-                            child: Container(
-                              width: 20,
-                              height: 1.2,
-                              color: frameColor,
-                            ),
-                          ),
-                          Center(
-                            child: Container(
-                              width: 1.2,
-                              height: 20,
-                              color: frameColor,
-                            ),
-                          ),
-                        ],
-                      ),
-                    ),
-                  ),
-                ],
-              ),
-            ),
-          ),
-
-          // 3. Bouton retour
-          Positioned(
-            top: 40,
-            left: 20,
-            child: CircleAvatar(
-              backgroundColor: Colors.black54,
-              child: IconButton(
-                icon: const Icon(Icons.arrow_back, color: Colors.white),
-                onPressed: () {
-                  _stopAlignmentDetection();
-                  _stopParallelismDetection(); // NOUVEAU
-                  setState(() {
-                    _showLiveCamera = false;
-                  });
-                },
-              ),
-            ),
-          ),
-
-          // 4. Message d'alignement principal (texte dynamique IMU)
-          Positioned(
-            top: 50,
-            left: 0,
-            right: 0,
-            child: Center(
-              child: Container(
-                padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
-                decoration: BoxDecoration(
-                  color: Colors.black.withValues(alpha: 0.7),
-                  borderRadius: BorderRadius.circular(20),
-                ),
-                child: Text(
-                  alignmentMessage,
-                  style: TextStyle(
-                    color: frameColor,
-                    fontWeight: FontWeight.bold,
-                    fontSize: 12,
-                    letterSpacing: 1.2,
-                  ),
-                ),
-              ),
-            ),
-          ),
-
-          // NOUVEAU : Indicateur visuel des angles en bas à gauche
-          if (_parallelismData != null &&
-              _parallelismData!.status != ParallelismStatus.unknown)
-            Positioned(
-              bottom: 140,
-              left: 16,
-              child: _buildAngleIndicator(_parallelismData!),
-            ),
-
-          // Indicateur d'analyse en cours
-          if (_isAnalyzingFrame)
-            Positioned(
-              top: 45,
-              right: 20,
-              child: Container(
-                width: 10,
-                height: 10,
-                decoration: const BoxDecoration(
-                  color: Colors.white54,
-                  shape: BoxShape.circle,
-                ),
-              ),
-            ),
-
-          // 5. Bouton déclencheur
-          Positioned(
-            bottom: 40,
-            left: 0,
-            right: 0,
-            child: Center(
-              child: GestureDetector(
-                onTap: _isCapturing ? null : _takePictureManually,
-                child: Container(
-                  height: 80,
-                  width: 80,
-                  decoration: BoxDecoration(
-                    shape: BoxShape.circle,
-                    border: Border.all(color: Colors.white, width: 4),
-                  ),
-                  child: Center(
-                    child: Container(
-                      height: 64,
-                      width: 64,
-                      decoration: const BoxDecoration(
-                        color: Colors.white,
-                        shape: BoxShape.circle,
-                      ),
-                    ),
-                  ),
-                ),
-              ),
-            ),
-          ),
-
-          // 6. Overlay bloquant pendant la capture/traitement : empêche de
-          // bouger l'UI ou de relancer une capture tant que la photo n'est pas
-          // chargée (absorbe tous les gestes). Deux phases distinctes pour
-          // lever la confusion « puis-je bouger ? » :
-          //   • _capturedPreviewPath == null → capture physique en cours :
-          //     voile sur l'aperçu vivant + « Ne bougez pas ».
-          //   • _capturedPreviewPath != null → photo prise, traitement en
-          //     cours : on affiche l'image FIGÉE (le flux vivant disparaît)
-          //     + « Photo prise ✓ — vous pouvez bouger ».
-          if (_isCapturing)
-            Positioned.fill(
-              child: AbsorbPointer(
-                child: _capturedPreviewPath == null
-                    ? _buildCapturingOverlay()
-                    : _buildProcessingOverlay(_capturedPreviewPath!),
-              ),
-            ),
-        ],
-      ),
-    );
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Overlay PHASE 1 : capture physique en cours → l'utilisateur doit rester
-  // immobile. Voile semi-transparent par-dessus l'aperçu vivant.
-  // ─────────────────────────────────────────────────────────────────────────
-  Widget _buildCapturingOverlay() {
-    return Container(
-      color: Colors.black.withValues(alpha: 0.45),
-      child: const Center(
-        child: Column(
-          mainAxisSize: MainAxisSize.min,
-          children: [
-            CircularProgressIndicator(color: Colors.white),
-            SizedBox(height: 16),
-            Text(
-              'NE BOUGEZ PAS — CAPTURE…',
-              style: TextStyle(
-                color: Colors.white,
-                fontSize: 14,
-                fontWeight: FontWeight.w700,
-                letterSpacing: 1.2,
-              ),
-            ),
-          ],
-        ),
-      ),
-    );
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Overlay PHASE 2 : photo capturée, traitement en cours. On affiche l'image
-  // FIGÉE (l'aperçu vivant disparaît, plus d'ambiguïté) et on indique
-  // clairement que l'utilisateur peut maintenant bouger.
-  // ─────────────────────────────────────────────────────────────────────────
-  Widget _buildProcessingOverlay(String imagePath) {
-    return Stack(
-      fit: StackFit.expand,
-      children: [
-        // Image figée de la photo prise → recouvre totalement le flux caméra
-        Image.file(File(imagePath), fit: BoxFit.cover),
-        Container(
-          color: Colors.black.withValues(alpha: 0.55),
-          child: Center(
-            child: Column(
-              mainAxisSize: MainAxisSize.min,
-              children: [
-                const Icon(
-                  Icons.check_circle,
-                  color: Color(0xFF00FF00),
-                  size: 52,
-                ),
-                const SizedBox(height: 14),
-                const Text(
-                  'PHOTO PRISE',
-                  style: TextStyle(
-                    color: Color(0xFF00FF00),
-                    fontSize: 16,
-                    fontWeight: FontWeight.w700,
-                    letterSpacing: 1.2,
-                  ),
-                ),
-                const SizedBox(height: 20),
-                const SizedBox(
-                  width: 22,
-                  height: 22,
-                  child: CircularProgressIndicator(
-                    color: Colors.white,
-                    strokeWidth: 2.5,
-                  ),
-                ),
-                const SizedBox(height: 14),
-                Text(
-                  'Traitement… vous pouvez bouger',
-                  style: TextStyle(
-                    color: Colors.white.withValues(alpha: 0.85),
-                    fontSize: 13,
-                    fontWeight: FontWeight.w500,
-                  ),
-                ),
-              ],
-            ),
-          ),
-        ),
-      ],
-    );
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // NOUVEAU : Widget affichant les angles pitch/roll en temps réel
-  // ─────────────────────────────────────────────────────────────────────────
-  Widget _buildAngleIndicator(ParallelismData data) {
-    final Color color = data.isAligned ? const Color(0xFF00FF00) : Colors.orange;
-
-    return Container(
-      padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6),
-      decoration: BoxDecoration(
-        color: Colors.black.withValues(alpha: 0.6),
-        borderRadius: BorderRadius.circular(10),
-        border: Border.all(color: color.withValues(alpha: 0.5), width: 1),
-      ),
-      child: Column(
-        crossAxisAlignment: CrossAxisAlignment.start,
-        mainAxisSize: MainAxisSize.min,
-        children: [
-          _buildAngleRow(
-            label: 'Pitch',
-            value: data.pitchDegrees,
-            color: color,
-          ),
-          const SizedBox(height: 2),
-          _buildAngleRow(
-            label: 'Roll ',
-            value: data.rollDegrees,
-            color: color,
-          ),
-        ],
-      ),
-    );
-  }
-
-  Widget _buildAngleRow({
-    required String label,
-    required double value,
-    required Color color,
-  }) {
-    final String sign = value >= 0 ? '+' : '';
-    return Row(
-      mainAxisSize: MainAxisSize.min,
-      children: [
-        Text(
-          '$label: ',
-          style: const TextStyle(
-            color: Colors.white60,
-            fontSize: 11,
-            fontFamily: 'monospace',
-          ),
-        ),
-        Text(
-          '$sign${value.toStringAsFixed(1)}°',
-          style: TextStyle(
-            color: color,
-            fontSize: 11,
-            fontWeight: FontWeight.bold,
-            fontFamily: 'monospace',
-          ),
-        ),
-      ],
-    );
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Coins du cadre (inchangés)
-  // ─────────────────────────────────────────────────────────────────────────
-  Widget _buildCameraCorner({
-    bool TopLeft = false,
-    bool TopRight = false,
-    bool BottomLeft = false,
-    bool BottomRight = false,
-    Color color = const Color(0xFF00FF00),
-  }) {
-    return Positioned(
-      top: (TopLeft || TopRight) ? 10 : null,
-      bottom: (BottomLeft || BottomRight) ? 10 : null,
-      left: (TopLeft || BottomLeft) ? 10 : null,
-      right: (TopRight || BottomRight) ? 10 : null,
-      child: Container(
-        width: 20,
-        height: 20,
-        decoration: BoxDecoration(
-          border: Border(
-            top: (TopLeft || TopRight)
-                ? BorderSide(color: color, width: 4)
-                : BorderSide.none,
-            bottom: (BottomLeft || BottomRight)
-                ? BorderSide(color: color, width: 4)
-                : BorderSide.none,
-            left: (TopLeft || BottomLeft)
-                ? BorderSide(color: color, width: 4)
-                : BorderSide.none,
-            right: (TopRight || BottomRight)
-                ? BorderSide(color: color, width: 4)
-                : BorderSide.none,
-          ),
-        ),
-      ),
-    );
-  }
-
-  // ─────────────────────────────────────────────────────────────────────────
-  // Capture manuelle (MODIFIÉE : ajout dégradation post-capture pour perf)
-  // ─────────────────────────────────────────────────────────────────────────
-  Future<void> _takePictureManually() async {
-    if (_cameraController == null || !_cameraController!.value.isInitialized) {
-      return;
-    }
-
-    // Garde anti-double-capture : tout appui supplémentaire pendant le
-    // traitement est ignoré (évite les photos multiples / états incohérents).
-    if (_isCapturing) return;
-
-    setState(() {
-      _isCapturing = true;
-      _isLoading = true;
-      _capturedPreviewPath = null; // phase « capture en cours »
-    });
+  Future<void> _captureImageFromGallery() async {
+    setState(() => _isLoading = true);
     try {
-      // On stoppe le flux d'analyse (obligatoire avant takePicture) puis on
-      // capture IMMÉDIATEMENT, sans étape intermédiaire. Le reset de zoom
-      // inutile (aucun zoom possible sur cet écran) a été retiré pour que la
-      // photo parte sans délai perceptible.
-      _stopAlignmentDetection();
-      _stopParallelismDetection();
-
-      final XFile photo = await _cameraController!.takePicture();
-
-      // La photo est PHYSIQUEMENT capturée : on gèle l'aperçu en affichant
-      // l'image prise (le flux caméra « vivant » disparaît) et on bascule le
-      // message sur « vous pouvez bouger ». Tout ce qui suit n'est que du
-      // traitement et n'exige plus l'immobilité de l'utilisateur.
-      if (mounted) {
-        setState(() => _capturedPreviewPath = photo.path);
-      }
-
-      // Pas de redressement perspective automatique ici : il déformait l'image
-      // (écrasement en carré + rotation de l'axe de l'ellipse) et gelait le
-      // thread UI. Le recentrage ET la rotation se font manuellement à l'écran
-      // de centrage suivant, qui est précis et non destructeur.
-      String finalPath = photo.path;
-
-      // PERF : on dégrade fortement la photo juste après la capture.
-      // Une résolution réduite suffit pour la calibration et le plotting,
-      // et accélère nettement le décodage à chaque écran (chargement plotting).
-      try {
-        finalPath = await _downscaleForPipeline(finalPath);
-      } catch (e) {
-        debugPrint('Downscale ignoré: $e');
-      }
-
-      if (!mounted) return;
-      setState(() {
-        _selectedImagePath = finalPath;
-        _showLiveCamera = false;
-      });
-
-      _analyzeImage();
-    } catch (e) {
-      debugPrint('Erreur lors du clic photo: $e');
-    } finally {
-      if (mounted) {
+      final XFile? image = await _picker.pickImage(
+        source: ImageSource.gallery,
+        // PERF : limite d'import plus agressive pour accélérer le pipeline
+        maxWidth: 1280,
+        maxHeight: 1280,
+        imageQuality: 75,
+      );
+      if (image != null) {
         setState(() {
-          _isLoading = false;
-          _isCapturing = false;
-          _capturedPreviewPath = null;
+          _selectedImagePath = image.path;
         });
+        _analyzeImage();
       }
+    } catch (e) {
+      debugPrint('Erreur galerie: $e');
+    } finally {
+      if (mounted) setState(() => _isLoading = false);
     }
   }
 
-  /// Réduit fortement la résolution de la photo pour accélérer tous les
-  /// écrans suivants (crop, calibration, plotting). 1080 px de côté max
-  /// + JPEG qualité 70 : largement suffisant pour la détection visuelle.
-  ///
-  /// Baisser `maxSide` (ex. 900) ou `quality` (ex. 60) rend le chargement
-  /// encore plus rapide au prix d'un peu de finesse à l'écran.
-  Future<String> _downscaleForPipeline(String sourcePath) async {
-    // On résout le chemin de sortie sur le thread UI (path_provider a besoin
-    // du canal de plateforme), puis tout le travail lourd (décodage, resize,
-    // réencodage JPEG) part dans un Isolate → aucun gel du thread UI.
-    final tempDir = await getTemporaryDirectory();
-    final outPath =
-        '${tempDir.path}/downscaled_${DateTime.now().millisecondsSinceEpoch}.jpg';
+  void _analyzeImage() {
+    if (_selectedImagePath == null) return;
 
-    return Isolate.run(() {
-      final bytes = File(sourcePath).readAsBytesSync();
-      final decoded = img.decodeImage(bytes);
-      if (decoded == null) return sourcePath;
-
-      const int maxSide = 1080;
-      final int longest = math.max(decoded.width, decoded.height);
-      if (longest <= maxSide) {
-        return sourcePath; // déjà assez petite, rien à faire
-      }
-
-      final double ratio = maxSide / longest;
-      final resized = img.copyResize(
-        decoded,
-        width: (decoded.width * ratio).round(),
-        height: (decoded.height * ratio).round(),
-        interpolation: img.Interpolation.linear, // rapide
-      );
-
-      File(outPath).writeAsBytesSync(img.encodeJpg(resized, quality: 70));
-      return outPath;
-    });
+    Navigator.push(
+      context,
+      MaterialPageRoute(
+        builder: (_) => CropScreen(
+          imagePath: _selectedImagePath!,
+          targetType: _selectedType,
+        ),
+      ),
+    );
   }
 
   // ─────────────────────────────────────────────────────────────────────────
-  // Helpers UI (inchangés)
+  // Helpers UI
   // ─────────────────────────────────────────────────────────────────────────
   Widget _buildSectionTitle(String title) {
     return Text(
@@ -1003,41 +267,4 @@ class _CaptureScreenState extends State<CaptureScreen>
       ),
     );
   }
-
-  Future<void> _captureImageFromGallery() async {
-    setState(() => _isLoading = true);
-    try {
-      final XFile? image = await _picker.pickImage(
-        source: ImageSource.gallery,
-        // PERF : limite d'import plus agressive pour accélérer le pipeline
-        maxWidth: 1280,
-        maxHeight: 1280,
-        imageQuality: 75,
-      );
-      if (image != null) {
-        setState(() {
-          _selectedImagePath = image.path;
-        });
-        _analyzeImage();
-      }
-    } catch (e) {
-      debugPrint('Erreur galerie: $e');
-    } finally {
-      if (mounted) setState(() => _isLoading = false);
-    }
-  }
-
-  void _analyzeImage() {
-    if (_selectedImagePath == null) return;
-
-    Navigator.push(
-      context,
-      MaterialPageRoute(
-        builder: (_) => CropScreen(
-          imagePath: _selectedImagePath!,
-          targetType: _selectedType,
-        ),
-      ),
-    );
-  }
 }
\ No newline at end of file
diff --git a/lib/services/document_scanner_service.dart b/lib/services/document_scanner_service.dart
new file mode 100644
index 00000000..db5b9baa
--- /dev/null
+++ b/lib/services/document_scanner_service.dart
@@ -0,0 +1,54 @@
+import 'package:google_mlkit_document_scanner/google_mlkit_document_scanner.dart';
+
+/// Résultat du scan de document.
+class DocumentScanResult {
+  /// Chemin de l'image redressée (de face), ou null si l'utilisateur a annulé.
+  final String? imagePath;
+
+  /// true si un scan a bien été produit.
+  bool get success => imagePath != null;
+
+  const DocumentScanResult(this.imagePath);
+}
+
+/// Service qui lance le scanner de documents Google ML Kit.
+///
+/// Le scanner ouvre une UI plein écran fournie par Google Play Services :
+/// caméra, détection des bords de la feuille en direct, recadrage manuel des
+/// 4 coins, puis renvoie l'image REDRESSÉE de face. Idéal pour une cible de
+/// tir, qui est imprimée sur un carton/feuille rectangulaire.
+///
+/// NOTE : disponible uniquement sur Android (fonctionnalité ML Kit en bêta).
+class DocumentScannerService {
+  /// Lance le scanner et renvoie le chemin de l'image redressée.
+  ///
+  /// [pageLimit] est fixé à 1 (une seule cible par scan).
+  /// On désactive l'import galerie ici car la galerie est gérée séparément.
+  ///
+  /// IMPORTANT : on utilise [ScannerMode.base] et NON [ScannerMode.full].
+  /// - `full`/`filter` appliquent des filtres "document" (noir & blanc,
+  ///   rehaussement type photocopie) → détruit les couleurs de la cible.
+  /// - `base` ne fait QUE le recadrage + le redressement de perspective
+  ///   (mise de face), en conservant l'image en couleurs réelles. C'est
+  ///   indispensable pour pouvoir détecter ensuite les impacts.
+  Future<DocumentScanResult> scanTarget() async {
+    final options = DocumentScannerOptions(
+      mode: ScannerMode.base, // redressement seul, sans filtre couleur
+      pageLimit: 1,
+      isGalleryImport: false,
+    );
+
+    final scanner = DocumentScanner(options: options);
+    try {
+      final DocumentScanningResult result = await scanner.scanDocument();
+      final images = result.images;
+      if (images.isEmpty) {
+        return const DocumentScanResult(null);
+      }
+      return DocumentScanResult(images.first);
+    } finally {
+      // Libère les ressources natives du scanner.
+      await scanner.close();
+    }
+  }
+}
\ No newline at end of file