Merge branch 'feature/detection-cible-au-sol'

lib/features/analysis/analysis_provider.dart

@@ -239,12 +239,16 @@ class AnalysisProvider extends ChangeNotifier {
   }
 
   /// Exporte l'image et le json vers le backend IA.
-  /// [sessionId], [distance] et [weapon] proviennent du SessionProvider de
+  /// [sessionId], [distance] et [caliber] proviennent du SessionProvider de
   /// l'écran appelant, pour que le dataset contienne les vraies métadonnées.
+  ///
+  /// Le nom de l'arme n'est volontairement pas transmis : il est souvent
+  /// personnalisé par l'utilisateur et n'apporte rien au modèle de détection.
   Future<AiExportResult> exportToAiBackend({
     String? sessionId,
     int? distance,
-    String? weapon,
+    String? caliber,
+    int? expectedShots,
   }) async {
     if (_imagePath == null || _targetType == null) {
       _errorMessage = "Impossible d'exporter : image ou type de cible manquant.";
@@ -269,7 +273,8 @@ class AnalysisProvider extends ChangeNotifier {
       targetRadius: _targetRadius,
       shots: _shots,
       distanceMeters: distance ?? 25,
-      weaponName: weapon ?? 'Unknown',
+      caliber: caliber ?? 'unknown',
+      expectedShots: expectedShots,
     );
 
     _state = AnalysisState.success;

lib/features/analysis/analysis_screen.dart

@@ -784,7 +784,7 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
                   // qu'elle ressorte sur le bouton.
                   color: Colors.white,
                 ),
-                label: 'TERMINER TOUT ET EXPORTER',
+                label: 'TERMINER ET CONTRIBUER À L\'IA',
                 color: AppTheme.warningColor,
                 onPressed: () =>
                     _finishSession(context, provider, export: true),
@@ -942,7 +942,12 @@ class _AnalysisScreenContentState extends State<_AnalysisScreenContent> {
         exportResult = await provider.exportToAiBackend(
           sessionId: sessionProvider.activeSessionId,
           distance: sessionProvider.distance,
-          weapon: sessionProvider.currentWeapon,
+          caliber: sessionProvider.currentWeaponCaliber,
+          // Hors session, shotsPerTarget vaut sa valeur par defaut : mieux
+          // vaut ne rien annoncer qu'annoncer un nombre faux.
+          expectedShots: sessionProvider.isSessionActive
+              ? sessionProvider.shotsPerTarget
+              : null,
         );
         messenger.hideCurrentSnackBar();
       }

lib/features/capture/capture_screen.dart

@@ -169,8 +169,9 @@ class _CaptureScreenState extends State<CaptureScreen>
       final prev = _parallelismData;
       final bool changed = prev == null ||
           prev.status != data.status ||
-          prev.pitchDegrees.toStringAsFixed(1) !=
-              data.pitchDegrees.toStringAsFixed(1) ||
+          prev.pose != data.pose ||
+          prev.pitchDeviation.toStringAsFixed(1) !=
+              data.pitchDeviation.toStringAsFixed(1) ||
           prev.rollDegrees.toStringAsFixed(1) !=
               data.rollDegrees.toStringAsFixed(1);
 
@@ -218,16 +219,21 @@ class _CaptureScreenState extends State<CaptureScreen>
       return 'ALIGNEZ LA CIBLE DANS LE CADRE';
     }
 
+    final bool onGround = _parallelismData!.pose == TargetPose.ground;
+
     // 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'
+      if (_targetReady) return 'PARFAIT — CIBLE DÉTECTÉE, PRÊT';
+      return onGround
+          ? 'CIBLE AU SOL — PRÊT À PHOTOGRAPHIER'
           : '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;
+    // Mal aligné → message directif selon l'axe le plus dévié.
+    // On raisonne sur les écarts à la pose détectée, pas sur le tangage brut :
+    // à plat, celui-ci vaut -90° alors que le cadrage peut être parfait.
+    final double pitch = _parallelismData!.pitchDeviation;
+    final double roll = _parallelismData!.rollDeviation;
 
     if (pitch.abs() >= roll.abs()) {
       return pitch > 0
@@ -776,15 +782,25 @@ class _CaptureScreenState extends State<CaptureScreen>
         crossAxisAlignment: CrossAxisAlignment.start,
         mainAxisSize: MainAxisSize.min,
         children: [
+          Text(
+            data.pose == TargetPose.ground ? 'CIBLE AU SOL' : 'CIBLE AU MUR',
+            style: TextStyle(
+              color: color,
+              fontSize: 10,
+              fontWeight: FontWeight.w700,
+              letterSpacing: 0.5,
+            ),
+          ),
+          const SizedBox(height: 4),
           _buildAngleRow(
             label: 'Pitch',
-            value: data.pitchDegrees,
+            value: data.pitchDeviation,
             color: color,
           ),
           const SizedBox(height: 2),
           _buildAngleRow(
             label: 'Roll ',
-            value: data.rollDegrees,
+            value: data.rollDeviation,
             color: color,
           ),
         ],

lib/features/session/session_provider.dart

@@ -6,6 +6,7 @@ class SessionProvider extends ChangeNotifier {
   DateTime? get sessionDate => _sessionDate;
   String? _currentWeaponName;
   String? _currentWeaponId;
+  String? _currentWeaponCaliber;
   int _shotsPerTarget = 5;
   int _distance = 25;
   String? _activeSessionId;
@@ -14,6 +15,11 @@ class SessionProvider extends ChangeNotifier {
 
   String? get currentWeapon => _currentWeaponName;
   String? get currentWeaponId => _currentWeaponId;
+
+  /// Calibre de l'arme de la session. Contrairement au nom d'arme, il ne
+  /// designe pas l'utilisateur : c'est la seule donnee d'arme envoyee au
+  /// backend d'entrainement (le diametre des trous en depend).
+  String? get currentWeaponCaliber => _currentWeaponCaliber;
   int get shotsPerTarget => _shotsPerTarget;
   int get distance => _distance;
   bool get isSessionActive => _isSessionActive;
@@ -23,9 +29,10 @@ class SessionProvider extends ChangeNotifier {
   int get totalSessionScore => _currentAnalyses.fold(0, (sum, a) => sum + a.totalScore);
   int get targetCount => _currentAnalyses.length;
 
-  void startSession(String weaponName, int shots, String sessionId, {String? weaponId, int distance = 25, DateTime? date}) {
+  void startSession(String weaponName, int shots, String sessionId, {String? weaponId, String? caliber, int distance = 25, DateTime? date}) {
     _currentWeaponName = weaponName;
     _currentWeaponId = weaponId;
+    _currentWeaponCaliber = caliber;
     _shotsPerTarget = shots;
     _distance = distance;
     _sessionDate = date ?? DateTime.now();
@@ -45,6 +52,7 @@ class SessionProvider extends ChangeNotifier {
     _activeSessionId = null;
     _currentWeaponId = null;
     _currentWeaponName = null;
+    _currentWeaponCaliber = null;
     _currentAnalyses.clear();
     _distance = 25;
     notifyListeners();

lib/features/session/session_setup_screen.dart

@@ -27,8 +27,14 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
 
   DateTime _selectedDate = DateTime.now();
 
+  /// Valeur sentinelle de l'item "Ajouter une nouvelle arme" du menu deroulant.
+  static const String _addWeaponValue = '__add_weapon__';
+
+  final GlobalKey<FormFieldState<String>> _weaponFieldKey =
+      GlobalKey<FormFieldState<String>>();
+
   static const List<int> _presetDistances = [10, 15, 25, 50, 100, 200];
-  static const List<int> _presetShots = [3, 5, 10, 15, 20, 30];
+  static const List<int> _presetShots = [3, 5, 10, 15, 20, 30, 50];
 
   @override
   void initState() {
@@ -44,8 +50,21 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
     if (mounted) {
       setState(() {
         _availableWeapons = weapons;
-        if (_availableWeapons.isNotEmpty && _selectedWeapon == null) {
-          _selectedWeapon = _availableWeapons.first;
+
+        // Les armes rechargees sont de nouvelles instances (Weapon n'a pas
+        // d'operator ==) et l'arme selectionnee a pu etre supprimee : on
+        // re-resout la selection par identifiant.
+        final previousId = _selectedWeapon?.id;
+        _selectedWeapon = null;
+        for (final weapon in weapons) {
+          if (weapon.id == previousId) {
+            _selectedWeapon = weapon;
+            break;
+          }
+        }
+
+        if (_selectedWeapon == null && weapons.isNotEmpty) {
+          _selectedWeapon = weapons.first;
           _updateSettingsForWeapon(_selectedWeapon!);
         }
         _isLoadingWeapons = false;
@@ -53,6 +72,35 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
     }
   }
 
+  Future<void> _openArmory() async {
+    final knownIds = _availableWeapons.map((w) => w.id).toSet();
+
+    await Navigator.push(
+      context,
+      MaterialPageRoute(builder: (_) => const WeaponListScreen()),
+    );
+    if (!mounted) return;
+
+    await _loadWeapons();
+    if (!mounted) return;
+
+    // Selectionne automatiquement l'arme qui vient d'etre ajoutee.
+    Weapon? added;
+    for (final weapon in _availableWeapons) {
+      if (!knownIds.contains(weapon.id)) {
+        added = weapon;
+        break;
+      }
+    }
+    if (added != null) {
+      final newWeapon = added;
+      setState(() {
+        _selectedWeapon = newWeapon;
+        _updateSettingsForWeapon(newWeapon);
+      });
+    }
+  }
+
   void _updateSettingsForWeapon(Weapon weapon) {
     _shotsPerTarget = weapon.magazineCapacity > 0 ? weapon.magazineCapacity : 5;
     _distance = (weapon.type == WeaponType.handgun) ? 25 : 50;
@@ -92,6 +140,7 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
         _shotsPerTarget,
         sessionId,
         weaponId: _selectedWeapon!.id,
+        caliber: _selectedWeapon!.caliber,
         distance: _distance,
         date: _selectedDate,
       );
@@ -177,12 +226,7 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
           ),
           const SizedBox(height: 20),
           ElevatedButton.icon(
-            onPressed: () {
-              Navigator.push(
-                context,
-                MaterialPageRoute(builder: (_) => const WeaponListScreen()),
-              ).then((_) => _loadWeapons());
-            },
+            onPressed: _openArmory,
             icon: const Icon(Icons.shield),
             label: const Text('Aller à l\'armurerie'),
           ),
@@ -213,26 +257,60 @@ class _SessionSetupScreenState extends State<SessionSetupScreen> {
               ],
             ),
             const SizedBox(height: 16),
-            DropdownButtonFormField<Weapon>(
-              initialValue: _selectedWeapon,
+            DropdownButtonFormField<String>(
+              key: _weaponFieldKey,
+              initialValue: _selectedWeapon?.id,
               decoration: const InputDecoration(
                 labelText: 'Arme utilisée',
                 prefixIcon: Icon(Icons.shield_outlined),
               ),
-              items: _availableWeapons
-                  .map(
-                    (w) => DropdownMenuItem(
-                      value: w,
-                      child: Text('${w.displayName} (${w.caliber})'),
-                    ),
-                  )
-                  .toList(),
+              items: [
+                ..._availableWeapons.map(
+                  (w) => DropdownMenuItem(
+                    value: w.id,
+                    child: Text('${w.displayName} (${w.caliber})'),
+                  ),
+                ),
+                DropdownMenuItem(
+                  value: _addWeaponValue,
+                  child: Row(
+                    children: [
+                      Icon(
+                        Icons.add_circle_outline,
+                        size: 18,
+                        color: Theme.of(context).colorScheme.primary,
+                      ),
+                      const SizedBox(width: 8),
+                      Text(
+                        'Ajouter une nouvelle arme',
+                        style: TextStyle(
+                          fontWeight: FontWeight.w600,
+                          color: Theme.of(context).colorScheme.primary,
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+              ],
               onChanged: (value) {
-                if (value != null) {
-                  setState(() {
-                    _selectedWeapon = value;
-                    _updateSettingsForWeapon(value);
-                  });
+                if (value == null) return;
+
+                if (value == _addWeaponValue) {
+                  // L'item d'action n'est pas une arme : on restaure aussitot
+                  // la selection precedente avant d'ouvrir l'armurerie.
+                  _weaponFieldKey.currentState?.didChange(_selectedWeapon?.id);
+                  _openArmory();
+                  return;
+                }
+
+                for (final weapon in _availableWeapons) {
+                  if (weapon.id == value) {
+                    setState(() {
+                      _selectedWeapon = weapon;
+                      _updateSettingsForWeapon(weapon);
+                    });
+                    break;
+                  }
                 }
               },
             ),

lib/features/settings/settings_screen.dart

@@ -462,7 +462,23 @@ class _SettingsScreenState extends State<SettingsScreen> {
               ),
               const SizedBox(height: 14),
               const Text(
-                '🔒 Anonymat Garanti : L\'envoi est totalement anonymisé. Votre identité est remplacée par un hash cryptographique.',
+                '📤 Ce qui est envoyé : la photo de la cible, la position des '
+                'impacts que vous avez placés, la distance de tir, le calibre et '
+                'le nombre de coups prévus.',
+                style: TextStyle(fontSize: 13),
+              ),
+              const SizedBox(height: 10),
+              const Text(
+                '🚫 Ce qui ne l\'est pas : la géolocalisation de la photo (retirée '
+                'avant l\'envoi), le nom de votre arme, et le modèle de votre appareil.',
+                style: TextStyle(fontSize: 13),
+              ),
+              const SizedBox(height: 10),
+              const Text(
+                '🔒 Pseudonymat : votre identité est remplacée par un hash '
+                'cryptographique. Il reste le même d\'un envoi à l\'autre, afin de '
+                'rattacher vos contributions à votre compte (récompenses, '
+                'modération, suppression sur demande).',
                 style: TextStyle(fontSize: 13),
               ),
               const SizedBox(height: 10),

lib/services/ai_export_service.dart

@@ -2,7 +2,7 @@ import 'dart:convert';
 import 'package:flutter/foundation.dart';
 import 'dart:io';
 import 'package:http/http.dart' as http;
-import 'package:device_info_plus/device_info_plus.dart';
+import 'package:image/image.dart' as img;
 import 'package:crypto/crypto.dart';
 import '../data/models/shot.dart';
 import '../data/models/target_type.dart';
@@ -64,30 +64,37 @@ class AiExportResult {
 }
 
 class AiExportService {
-  /// Extrait les informations de l'appareil
-  Future<Map<String, dynamic>> _getDeviceInfo() async {
-    final DeviceInfoPlugin deviceInfoPlugin = DeviceInfoPlugin();
-    Map<String, dynamic> deviceData = {'model': 'Unknown', 'os': 'Unknown'};
-
+  /// Retire toutes les metadonnees de la photo avant l'envoi.
+  ///
+  /// Une photo de cible prise au telephone embarque un bloc EXIF qui contient
+  /// typiquement la position GPS du stand de tir, la date exacte et le modele
+  /// d'appareil. Rien de tout cela n'est utile au modele de detection.
+  ///
+  /// L'orientation est d'abord appliquee physiquement aux pixels : les
+  /// coordonnees d'impact sont normalisees sur l'image telle qu'elle est
+  /// affichee dans l'app (Flutter applique l'orientation EXIF), donc supprimer
+  /// le tag sans redresser l'image ferait pivoter la photo par rapport a ses
+  /// propres annotations.
+  ///
+  /// Retourne null si l'image est illisible.
+  @visibleForTesting
+  Uint8List? stripMetadata(Uint8List originalBytes) {
     try {
-      if (Platform.isAndroid) {
-        final androidInfo = await deviceInfoPlugin.androidInfo;
-        deviceData['model'] = '${androidInfo.brand} ${androidInfo.model}';
-        deviceData['os'] = 'Android ${androidInfo.version.release}';
-      } else if (Platform.isIOS) {
-        final iosInfo = await deviceInfoPlugin.iosInfo;
-        deviceData['model'] = iosInfo.name;
-        deviceData['os'] = '${iosInfo.systemName} ${iosInfo.systemVersion}';
-      } else if (Platform.isWindows) {
-        final windowsInfo = await deviceInfoPlugin.windowsInfo;
-        deviceData['model'] = 'Windows PC';
-        deviceData['os'] = 'Windows ${windowsInfo.majorVersion}.${windowsInfo.minorVersion}';
-      }
-    } catch (e) {
-      debugPrint('Erreur lors de la récupération des infos appareil: $e');
-    }
+      final decoded = img.decodeImage(originalBytes);
+      if (decoded == null) return null;
 
-    return deviceData;
+      final baked = img.bakeOrientation(decoded);
+
+      // bakeOrientation recopie tout l'EXIF sauf l'orientation : sans ce reset,
+      // le GPS survivrait au reencodage.
+      baked.exif = img.ExifData();
+
+      return img.encodeJpg(baked, quality: 90);
+    } catch (e) {
+      // Sur un fichier tronque, decodeImage leve au lieu de retourner null.
+      debugPrint('Photo illisible, export annule: $e');
+      return null;
+    }
   }
 
   /// Exporte l'image et les données de plotting vers le serveur
@@ -100,7 +107,8 @@ class AiExportService {
     required double targetRadius,
     required List<Shot> shots,
     int distanceMeters = 25,
-    String weaponName = 'Unknown',
+    String caliber = 'unknown',
+    int? expectedShots,
     String? apiUrl,
   }) async {
     try {
@@ -121,7 +129,13 @@ class AiExportService {
         );
       }
 
-      final deviceData = await _getDeviceInfo();
+      final sanitizedPhoto = stripMetadata(await file.readAsBytes());
+      if (sanitizedPhoto == null) {
+        return AiExportResult.error(
+          code: 'INVALID_IMAGE',
+          message: 'La photo de la cible est illisible et n\'a pas pu être envoyée.',
+        );
+      }
 
       final corners = [
         {"norm_x": targetCenterX - targetRadius, "norm_y": targetCenterY - targetRadius},
@@ -155,11 +169,15 @@ class AiExportService {
         "session_id": sessionId,
         "wallet_hash": walletHash,
         "timestamp": DateTime.now().toIso8601String(),
-        "device_info": deviceData,
         "target_metadata": {
           "type": targetType.name,
           "distance_meters": distanceMeters,
-          "weapon": weaponName,
+          "caliber": caliber,
+          // Nombre de coups prevus pour cette cible, null hors session.
+          // Un ecart avec le nombre d'impacts ne signifie pas que le
+          // marquage est faux (un coup peut etre parti hors papier) : c'est
+          // au tri du dataset d'en decider, pas au client.
+          "expected_shots": expectedShots,
         },
         "plotting": {
           "target_corners": corners,
@@ -169,7 +187,11 @@ class AiExportService {
 
       request.fields['plotting'] = jsonEncode(plottingJson);
       request.files.add(
-        await http.MultipartFile.fromPath('photo', imagePath),
+        http.MultipartFile.fromBytes(
+          'photo',
+          sanitizedPhoto,
+          filename: 'target.jpg',
+        ),
       );
 
       final streamedResponse = await request.send().timeout(

lib/services/parallelism_service.dart

@@ -1,5 +1,6 @@
 import 'dart:async';
 import 'dart:math' as math;
+import 'package:flutter/foundation.dart';
 import 'package:sensors_plus/sensors_plus.dart';
 
 /// Statut de parallélisme retourné en temps réel.
@@ -14,31 +15,67 @@ enum ParallelismStatus {
   misaligned,
 }
 
+/// Pose de prise de vue déduite de l'inclinaison de l'appareil.
+enum TargetPose {
+  /// Cible accrochée verticalement : l'appareil est tenu droit.
+  wall,
+
+  /// Cible posée au sol : l'appareil est à plat, caméra vers le bas.
+  ground,
+}
+
 /// Données de parallélisme calculées à chaque frame capteur.
 class ParallelismData {
   final ParallelismStatus status;
 
-  /// Inclinaison avant/arrière en degrés (0° = parfaitement vertical).
+  /// Pose détectée automatiquement, qui sert de référence aux écarts.
+  final TargetPose pose;
+
+  /// Inclinaison avant/arrière brute en degrés (0° = appareil vertical,
+  /// +90° = appareil à plat, caméra vers le sol).
   final double pitchDegrees;
 
   /// Inclinaison gauche/droite en degrés (0° = parfaitement droit).
   final double rollDegrees;
 
+  /// Écart de tangage par rapport à la pose détectée.
+  ///
+  /// En pose [TargetPose.wall] il vaut exactement [pitchDegrees] ; en pose
+  /// [TargetPose.ground] il mesure l'écart aux +90° de l'appareil à plat.
+  /// C'est cette valeur qu'il faut afficher : le tangage brut vaudrait -90°
+  /// alors que le cadrage est parfait.
+  final double pitchDeviation;
+
   const ParallelismData({
     required this.status,
+    required this.pose,
     required this.pitchDegrees,
     required this.rollDegrees,
+    required this.pitchDeviation,
   });
 
   bool get isAligned => status == ParallelismStatus.aligned;
 
+  /// Écart latéral. Le roulis se mesure de la même façon dans les deux poses.
+  double get rollDeviation => rollDegrees;
+
   @override
   String toString() =>
-      'ParallelismData(status: $status, pitch: ${pitchDegrees.toStringAsFixed(1)}°, roll: ${rollDegrees.toStringAsFixed(1)}°)';
+      'ParallelismData(status: $status, pose: $pose, pitch: ${pitchDegrees.toStringAsFixed(1)}°, '
+      'écart: ${pitchDeviation.toStringAsFixed(1)}°, roll: ${rollDegrees.toStringAsFixed(1)}°)';
 }
 
 /// Service de détection du parallélisme par accéléromètre.
 ///
+/// Deux poses de prise de vue sont reconnues, et celle dont l'appareil est le
+/// plus proche est retenue automatiquement :
+///
+///   [TargetPose.wall]   — cible au mur, appareil vertical (tangage ≈ 0°)
+///   [TargetPose.ground] — cible au sol, appareil à plat (tangage ≈ +90°)
+///
+/// Seul le tangage positif vaut pour la pose au sol : à plat écran vers le
+/// haut, la caméra vise le plafond et le vert n'aurait aucun sens.
+///
 /// Implémente une hystérésis à deux seuils pour éviter le clignotement :
 ///
 ///   État actuel = misaligned → passe à aligned si angle < [alignThreshold]
@@ -58,6 +95,13 @@ class ParallelismService {
   /// Doit être > alignThreshold pour créer la zone d'hystérésis.
   final double misalignThreshold;
 
+  /// Écart minimum en faveur de l'autre pose pour basculer.
+  ///
+  /// Les deux poses sont séparées de 90°, donc la bascule se joue vers 45° —
+  /// très loin des deux zones vertes. Cette marge évite seulement que
+  /// l'étiquette de pose clignote pile à la frontière.
+  static const double poseSwitchMargin = 5.0;
+
   StreamSubscription<AccelerometerEvent>? _subscription;
   final StreamController<ParallelismData> _controller =
   StreamController<ParallelismData>.broadcast();
@@ -65,6 +109,9 @@ class ParallelismService {
   /// État interne mémorisé entre deux frames (cœur de l'hystérésis).
   ParallelismStatus _currentStatus = ParallelismStatus.unknown;
 
+  /// Pose retenue à la frame précédente, pour l'hystérésis de pose.
+  TargetPose? _currentPose;
+
   ParallelismService({
     this.alignThreshold = 25.0,
     this.misalignThreshold = 32.0,
@@ -86,10 +133,13 @@ class ParallelismService {
         // Simulateur ou capteur absent — on reste en "unknown" sans bloquer l'UI
         if (!_controller.isClosed) {
           _currentStatus = ParallelismStatus.unknown;
+          _currentPose = null;
           _controller.add(const ParallelismData(
             status: ParallelismStatus.unknown,
+            pose: TargetPose.wall,
             pitchDegrees: 0,
             rollDegrees: 0,
+            pitchDeviation: 0,
           ));
         }
       },
@@ -100,6 +150,7 @@ class ParallelismService {
     _subscription?.cancel();
     _subscription = null;
     _currentStatus = ParallelismStatus.unknown;
+    _currentPose = null;
   }
 
   void dispose() {
@@ -110,12 +161,18 @@ class ParallelismService {
   void _onAccelerometerEvent(AccelerometerEvent event) {
     if (_controller.isClosed) return;
 
-    final double gx = event.x;
-    final double gy = event.y;
-    final double gz = event.z;
+    final data = evaluate(event.x, event.y, event.z);
+    if (data != null) _controller.add(data);
+  }
 
+  /// Calcule la pose et le statut depuis une mesure d'accéléromètre.
+  ///
+  /// Met à jour l'état d'hystérésis, donc l'ordre des appels compte.
+  /// Retourne null sur une mesure aberrante, qu'il faut alors ignorer.
+  @visibleForTesting
+  ParallelismData? evaluate(double gx, double gy, double gz) {
     final double magnitude = math.sqrt(gx * gx + gy * gy + gz * gz);
-    if (magnitude < 1.0) return; // Données aberrantes
+    if (magnitude < 1.0) return null; // Données aberrantes
 
     // Normalisation par la magnitude réelle (indépendant de g exact)
     final double nx = gx / magnitude;
@@ -125,10 +182,39 @@ class ParallelismService {
     final double pitchDeg = math.asin(nz.clamp(-1.0, 1.0)) * (180.0 / math.pi);
     final double rollDeg = math.asin(nx.clamp(-1.0, 1.0)) * (180.0 / math.pi);
 
-    // Le critère de couleur = le PIRE des deux angles affichés à l'écran.
-    // Ainsi ce que voit l'utilisateur (Pitch / Roll) correspond exactement
-    // à la décision vert/orange : à 2° d'écart, on est largement dans le vert.
-    final double worstAngle = math.max(pitchDeg.abs(), rollDeg.abs());
+    // ── Choix de la pose ────────────────────────────────────────────────────
+    // Cible au mur : le tangage idéal est 0°. Formule d'origine, inchangée.
+    final double wallPitchDeviation = pitchDeg;
+    final double wallWorst = math.max(pitchDeg.abs(), rollDeg.abs());
+
+    // Cible au sol : le tangage idéal est +90° (caméra vers le bas). Écran vers
+    // le haut, le tangage vaut -90° et l'écart atteint 180° : la pose au sol ne
+    // peut alors jamais gagner, ce qui est exactement le comportement voulu.
+    final double groundPitchDeviation = pitchDeg - 90.0;
+    final double groundWorst =
+    math.max(groundPitchDeviation.abs(), rollDeg.abs());
+
+    if (_currentPose == null) {
+      _currentPose =
+      groundWorst < wallWorst ? TargetPose.ground : TargetPose.wall;
+    } else if (_currentPose == TargetPose.wall) {
+      if (groundWorst + poseSwitchMargin < wallWorst) {
+        _currentPose = TargetPose.ground;
+      }
+    } else {
+      if (wallWorst + poseSwitchMargin < groundWorst) {
+        _currentPose = TargetPose.wall;
+      }
+    }
+
+    final bool isGround = _currentPose == TargetPose.ground;
+    final double pitchDeviation =
+    isGround ? groundPitchDeviation : wallPitchDeviation;
+
+    // Le critère de couleur = le PIRE des deux écarts affichés à l'écran.
+    // Ainsi ce que voit l'utilisateur correspond exactement à la décision
+    // vert/orange : à 2° d'écart, on est largement dans le vert.
+    final double worstAngle = isGround ? groundWorst : wallWorst;
 
     // ── Hystérésis ──────────────────────────────────────────────────────────
     // Premier appel : on décide selon alignThreshold uniquement
@@ -152,10 +238,12 @@ class ParallelismService {
     }
     // ────────────────────────────────────────────────────────────────────────
 
-    _controller.add(ParallelismData(
+    return ParallelismData(
       status: _currentStatus,
+      pose: _currentPose!,
       pitchDegrees: pitchDeg,
       rollDegrees: rollDeg,
-    ));
+      pitchDeviation: pitchDeviation,
+    );
   }
 }

test/services/ai_export_service_test.dart

@@ -0,0 +1,61 @@
+import 'dart:typed_data';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:image/image.dart' as img;
+
+import 'package:bully/services/ai_export_service.dart';
+
+/// Construit un JPEG porteur de métadonnées EXIF comme le ferait un téléphone :
+/// position GPS, modèle d'appareil et orientation.
+Uint8List _photoWithExif({int orientation = 1}) {
+  final image = img.Image(width: 40, height: 20);
+  img.fill(image, color: img.ColorRgb8(120, 120, 120));
+
+  image.exif.imageIfd['Model'] = 'Pixel 8';
+  image.exif.imageIfd.orientation = orientation;
+  image.exif.gpsIfd['GPSLatitude'] = 48.8584;
+  image.exif.gpsIfd['GPSLongitude'] = 2.2945;
+
+  return img.encodeJpg(image);
+}
+
+void main() {
+  final service = AiExportService();
+
+  group('stripMetadata', () {
+    test('supprime le GPS et les autres métadonnées EXIF', () {
+      final original = _photoWithExif();
+
+      // Garde-fou : sans EXIF au départ, le test ne prouverait rien.
+      expect(img.decodeImage(original)!.exif.isEmpty, isFalse);
+
+      final stripped = service.stripMetadata(original);
+      final result = img.decodeImage(stripped!)!;
+
+      expect(result.exif.isEmpty, isTrue);
+      expect(result.exif.gpsIfd.isEmpty, isTrue);
+    });
+
+    test('applique l\'orientation aux pixels avant de retirer le tag', () {
+      // Orientation 6 = rotation de 90°, donc les dimensions s'inversent.
+      final original = _photoWithExif(orientation: 6);
+
+      final result = img.decodeImage(service.stripMetadata(original)!)!;
+
+      expect(result.width, 20);
+      expect(result.height, 40);
+      expect(result.exif.isEmpty, isTrue);
+    });
+
+    test('conserve les dimensions quand il n\'y a pas d\'orientation', () {
+      final result = img.decodeImage(service.stripMetadata(_photoWithExif())!)!;
+
+      expect(result.width, 40);
+      expect(result.height, 20);
+    });
+
+    test('retourne null sur une image illisible', () {
+      expect(service.stripMetadata(Uint8List.fromList([1, 2, 3, 4])), isNull);
+    });
+  });
+}

test/services/parallelism_service_test.dart

@@ -0,0 +1,136 @@
+import 'dart:math' as math;
+
+import 'package:flutter_test/flutter_test.dart';
+
+import 'package:bully/services/parallelism_service.dart';
+
+/// Vecteur de gravité mesuré par l'accéléromètre pour une pose donnée.
+///
+/// [pitch] et [roll] sont exprimés comme dans le service : le tangage vaut 0°
+/// appareil vertical et +90° appareil à plat caméra vers le sol.
+({double x, double y, double z}) gravity({
+  double pitch = 0,
+  double roll = 0,
+}) {
+  const double g = 9.81;
+  final double p = pitch * math.pi / 180.0;
+  final double r = roll * math.pi / 180.0;
+
+  final double nz = math.sin(p);
+  final double nx = math.sin(r);
+  // Ce qui reste va sur y, l'axe vertical de l'écran.
+  final double ny = math.sqrt(math.max(0.0, 1.0 - nz * nz - nx * nx));
+
+  return (x: nx * g, y: ny * g, z: nz * g);
+}
+
+ParallelismData evaluatePose(
+  ParallelismService service, {
+  double pitch = 0,
+  double roll = 0,
+}) {
+  final v = gravity(pitch: pitch, roll: roll);
+  final data = service.evaluate(v.x, v.y, v.z);
+  expect(data, isNotNull, reason: 'mesure jugée aberrante à tort');
+  return data!;
+}
+
+void main() {
+  group('pose cible au mur (comportement existant)', () {
+    test('appareil vertical → aligné', () {
+      final data = evaluatePose(ParallelismService());
+
+      expect(data.pose, TargetPose.wall);
+      expect(data.status, ParallelismStatus.aligned);
+      expect(data.pitchDeviation, closeTo(0, 0.5));
+    });
+
+    test('l\'écart de tangage reste le tangage brut', () {
+      final data = evaluatePose(ParallelismService(), pitch: 10);
+
+      expect(data.pose, TargetPose.wall);
+      expect(data.pitchDeviation, closeTo(data.pitchDegrees, 0.001));
+    });
+
+    test('inclinaison au-delà du seuil → désaligné', () {
+      final data = evaluatePose(ParallelismService(), pitch: 40);
+
+      expect(data.pose, TargetPose.wall);
+      expect(data.status, ParallelismStatus.misaligned);
+    });
+
+    test('roulis excessif → désaligné même si le tangage est bon', () {
+      final data = evaluatePose(ParallelismService(), roll: 35);
+
+      expect(data.status, ParallelismStatus.misaligned);
+    });
+  });
+
+  group('pose cible au sol', () {
+    test('appareil à plat caméra vers le bas → aligné', () {
+      final data = evaluatePose(ParallelismService(), pitch: 90);
+
+      expect(data.pose, TargetPose.ground);
+      expect(data.status, ParallelismStatus.aligned);
+      expect(data.pitchDeviation, closeTo(0, 0.5));
+    });
+
+    test('l\'écart se mesure par rapport à +90°, pas à 0°', () {
+      final data = evaluatePose(ParallelismService(), pitch: 80);
+
+      expect(data.pose, TargetPose.ground);
+      expect(data.pitchDeviation, closeTo(-10, 0.5));
+      expect(data.status, ParallelismStatus.aligned);
+    });
+
+    test('à plat mais trop incliné → désaligné', () {
+      final data = evaluatePose(ParallelismService(), pitch: 50);
+
+      expect(data.status, ParallelismStatus.misaligned);
+    });
+
+    test('à plat écran vers le haut → jamais aligné', () {
+      // La caméra vise le plafond : le vert n'aurait aucun sens.
+      final data = evaluatePose(ParallelismService(), pitch: -90);
+
+      expect(data.pose, TargetPose.wall);
+      expect(data.status, ParallelismStatus.misaligned);
+    });
+  });
+
+  group('hystérésis', () {
+    test('le vert survit à un léger tremblement entre les deux seuils', () {
+      final service = ParallelismService();
+
+      expect(evaluatePose(service).status, ParallelismStatus.aligned);
+      // 28° est au-dessus du seuil d'entrée (25°) mais sous celui de sortie (32°).
+      expect(evaluatePose(service, pitch: 28).status, ParallelismStatus.aligned);
+      expect(evaluatePose(service, pitch: 40).status, ParallelismStatus.misaligned);
+      // Repasser sous 32° ne suffit pas : il faut redescendre sous 25°.
+      expect(evaluatePose(service, pitch: 28).status, ParallelismStatus.misaligned);
+      expect(evaluatePose(service, pitch: 20).status, ParallelismStatus.aligned);
+    });
+
+    test('la pose ne bascule pas pour un écart négligeable', () {
+      final service = ParallelismService();
+
+      expect(evaluatePose(service).pose, TargetPose.wall);
+      // Pile à la frontière des deux poses : on garde celle déjà retenue.
+      expect(evaluatePose(service, pitch: 45).pose, TargetPose.wall);
+      // Franchement du côté du sol : on bascule.
+      expect(evaluatePose(service, pitch: 70).pose, TargetPose.ground);
+    });
+
+    test('stop() remet la pose et le statut à zéro', () {
+      final service = ParallelismService();
+
+      expect(evaluatePose(service, pitch: 90).pose, TargetPose.ground);
+      service.stop();
+      expect(evaluatePose(service).pose, TargetPose.wall);
+    });
+  });
+
+  test('une mesure aberrante est ignorée', () {
+    expect(ParallelismService().evaluate(0, 0, 0), isNull);
+  });
+}